Smalltalk › ESUG

Re: destructDo:

_‹ Previous Topic Next Topic _›

Classic

List

Threaded

30 messages Options

NorbertHartl

Re: destructDo:

[:year :month :day | Date newDay: day month: month year: year]

valueWithPossibleArguments: (($- split: '2020-03-28') collect: #asNumber)

Norbert

Am 28.03.2020 um 13:42 schrieb Christian Haider <[hidden email]>:

Hi,

I am using a nice little method #destructDo: for a while now and it feels good.
In VisualWorks:
SequenceableCollection>>destructDo: aBlock
                                "Evaluate aBlock with the receiver's elements as parameters.
                                aBlock takes its arguments from the receiver.
                                'ok'
                                #(1 2 3) destructDo: [:a :b :c | a + b + c]
                                #(1 2 3) destructDo: [:a :b | a + b]
                                #(1 2 3) destructDo: [:a | a]
                                #(1 2 3) destructDo: [42]
                                'not ok'
                                #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]
                                "
                                ^aBlock cullWithArguments: self asArray

In Amber:
SequenceableCollection>>destructDo: aBlock
                                ^aBlock valueWithPossibleArguments: self

In Pharo and other dialects, I don’t know, but should be as easy.

For example you can do
                (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |
                               Date newDay: day monthNumber: month year: year]

I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.

Now the questions:
I am sure that others came up with this. Anybody knows?
What are you using for this pattern?
I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
What are you thinking about this?

Happy hacking,
                Christian

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

NorbertHartl

Re: destructDo:

Pressed send to fast. Just wanted to add that this is how it works in pharo but no collection selector.

Norbert

Am 28.03.2020 um 14:06 schrieb Norbert Hartl <[hidden email]>:

[:year :month :day | Date newDay: day month: month year: year]
valueWithPossibleArguments: (($- split: '2020-03-28') collect: #asNumber)

Norbert

Am 28.03.2020 um 13:42 schrieb Christian Haider <[hidden email]>:

Hi,

I am using a nice little method #destructDo: for a while now and it feels good.
In VisualWorks:
SequenceableCollection>>destructDo: aBlock
                                "Evaluate aBlock with the receiver's elements as parameters.
                                aBlock takes its arguments from the receiver.
                                'ok'
                                #(1 2 3) destructDo: [:a :b :c | a + b + c]
                                #(1 2 3) destructDo: [:a :b | a + b]
                                #(1 2 3) destructDo: [:a | a]
                                #(1 2 3) destructDo: [42]
                                'not ok'
                                #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]
                                "
                                ^aBlock cullWithArguments: self asArray

In Amber:
SequenceableCollection>>destructDo: aBlock
                                ^aBlock valueWithPossibleArguments: self

In Pharo and other dialects, I don’t know, but should be as easy.

For example you can do
                (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |
                               Date newDay: day monthNumber: month year: year]

I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.

Now the questions:
I am sure that others came up with this. Anybody knows?
What are you using for this pattern?
I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
What are you thinking about this?

Happy hacking,
                Christian

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

Mark Plas

Re: destructDo:

In reply to this post by NorbertHartl

Hello Christian,

" I don’t really like the name,"

Maybe you could call it #tupleDo:?

#(1 2 3) tupleDo: [:a :b :c | …]

Mark

Mark Plas
Software Engineer
T +32 2 467 34 30
[hidden email]

Nieuwe Gentsesteenweg 21/1
1702 Groot-Bijgaarden - Belgium
www.mediagenix.tv
Directions to MEDIAGENIX
This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.

From: Esug-list <[hidden email]> On Behalf Of Christian Haider
Sent: zaterdag 28 maart 2020 13:43
To: [hidden email]; [hidden email]; [hidden email]
Subject: [Esug-list] destructDo:

Hi,

I am using a nice little method #destructDo: for a while now and it feels good.

In VisualWorks:

SequenceableCollection>>destructDo: aBlock

"Evaluate aBlock with the receiver's elements as parameters.

aBlock takes its arguments from the receiver.

'ok'

#(1 2 3) destructDo: [:a :b :c | a + b + c]

#(1 2 3) destructDo: [:a :b | a + b]

#(1 2 3) destructDo: [:a | a]

#(1 2 3) destructDo: [42]

'not ok'

#(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]

^aBlock cullWithArguments: self asArray

In Amber:

SequenceableCollection>>destructDo: aBlock

^aBlock valueWithPossibleArguments: self

In Pharo and other dialects, I don’t know, but should be as easy.

For example you can do

(('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |

Date newDay: day monthNumber: month year: year]

I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.

Now the questions:

I am sure that others came up with this. Anybody knows?
What are you using for this pattern?
I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
What are you thinking about this?

Happy hacking,

Christian

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

NorbertHartl

Re: destructDo:

I think the name destructDo: comes from destructuring assignment.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment

Norbert

Am 28.03.2020 um 14:15 schrieb Mark Plas <[hidden email]>:

Hello Christian,

" I don’t really like the name,"

Maybe you could call it #tupleDo:?

                #(1 2 3) tupleDo: [:a :b :c | …]

Mark

Mark Plas
Software Engineer
T +32 2 467 34 30
[hidden email]

<logomgxnew_3d44337b-2535-4d6a-9f5f-3fdd565513ca.png>

Nieuwe Gentsesteenweg 21/1
1702 Groot-Bijgaarden - Belgium
<linkedin_75b9c4f1-6a2b-497c-aab8-df56fe16b8e3.png> <twitter_de4c3300-c6ab-4898-a962-b33ff662a322.png><Facebook-icon_6bef7545-f54e-4548-bfc4-1f07407f2642.png>www.mediagenix.tv
Directions to MEDIAGENIX

This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.
From: Esug-list <[hidden email]> On Behalf Of Christian Haider
Sent: zaterdag 28 maart 2020 13:43
To: [hidden email]; [hidden email]; [hidden email]
Subject: [Esug-list] destructDo:

Hi,

I am using a nice little method #destructDo: for a while now and it feels good.
In VisualWorks:
SequenceableCollection>>destructDo: aBlock
                                "Evaluate aBlock with the receiver's elements as parameters.
                                aBlock takes its arguments from the receiver.
                                'ok'
                                #(1 2 3) destructDo: [:a :b :c | a + b + c]
                                #(1 2 3) destructDo: [:a :b | a + b]
                                #(1 2 3) destructDo: [:a | a]
                                #(1 2 3) destructDo: [42]
                                'not ok'
                                #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]
                                "
                                ^aBlock cullWithArguments: self asArray

In Amber:
SequenceableCollection>>destructDo: aBlock
                                ^aBlock valueWithPossibleArguments: self

In Pharo and other dialects, I don’t know, but should be as easy.

For example you can do
                (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |
                               Date newDay: day monthNumber: month year: year]

I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.

Now the questions:
I am sure that others came up with this. Anybody knows?
What are you using for this pattern?
I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
What are you thinking about this?

Happy hacking,
                Christian

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

Graham McLeod

Re: destructDo:

How about: #mapTo:

Graham

[hidden email]

28 March 2020 at 15:35

How about #consume: ?

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

[hidden email]

28 March 2020 at 15:19

I think the name destructDo: comes from destructuring assignment.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment

Norbert

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

[hidden email]

28 March 2020 at 15:15

Hello Christian,

" I don’t really like the name,"

Maybe you could call it #tupleDo:?

                #(1 2 3) tupleDo: [:a :b :c | …]

Mark

Mark Plas

Software Engineer

T +32 2 467 34 30

[hidden email]

Nieuwe Gentsesteenweg 21/1

1702 Groot-Bijgaarden - Belgium

  www.mediagenix.tv

Directions to MEDIAGENIX

This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.

From: Esug-list [hidden email] On Behalf Of Christian Haider
Sent: zaterdag 28 maart 2020 13:43
To: [hidden email]; [hidden email]; [hidden email]
Subject: [Esug-list] destructDo:

Hi,

I am using a nice little method #destructDo: for a while now and it feels good.

In VisualWorks:

SequenceableCollection>>destructDo: aBlock

                                "Evaluate aBlock with the receiver's elements as parameters.

                                aBlock takes its arguments from the receiver.

                                'ok'

                                #(1 2 3) destructDo: [:a :b :c | a + b + c]

                                #(1 2 3) destructDo: [:a :b | a + b]

                                #(1 2 3) destructDo: [:a | a]

                                #(1 2 3) destructDo: [42]

                                'not ok'

                                #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]

                                "

                                ^aBlock cullWithArguments: self asArray

In Amber:

SequenceableCollection>>destructDo: aBlock

                                ^aBlock valueWithPossibleArguments: self

In Pharo and other dialects, I don’t know, but should be as easy.

For example you can do

                (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |

                               Date newDay: day monthNumber: month year: year]

I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.

Now the questions:

I am sure that others came up with this. Anybody knows?
What are you using for this pattern?
I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
What are you thinking about this?

Happy hacking,

                Christian

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

[hidden email]

28 March 2020 at 14:42

Hi,

I am using a nice little method #destructDo: for a while now and it feels good.
In VisualWorks:
SequenceableCollection>>destructDo: aBlock
                                "Evaluate aBlock with the receiver's elements as parameters.
                                aBlock takes its arguments from the receiver.
                                'ok'
                                #(1 2 3) destructDo: [:a :b :c | a + b + c]
                                #(1 2 3) destructDo: [:a :b | a + b]
                                #(1 2 3) destructDo: [:a | a]
                                #(1 2 3) destructDo: [42]
                                'not ok'
                                #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]
                                "
                                ^aBlock cullWithArguments: self asArray

In Amber:
SequenceableCollection>>destructDo: aBlock
                                ^aBlock valueWithPossibleArguments: self

In Pharo and other dialects, I don’t know, but should be as easy.

For example you can do
                (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |
                               Date newDay: day monthNumber: month year: year]

I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.

Now the questions:
I am sure that others came up with this. Anybody knows?
What are you using for this pattern?
I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
What are you thinking about this?

Happy hacking,
                Christian

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

mcleod.vcf (559 bytes) Download Attachment

Christophe Dony

Re: destructDo:

In reply to this post by Mark Plas

Hi.
I like tupleDo:

or matchDo:

and what about installing a full pattern matching, as in many languages e.g. Scheme : https://docs.racket-lang.org/reference/match.html

#(1 #(2 3 6 7) 4) matchDo: [:a (:b :@c) :d] | …]
here c would be #(3 6 7)

may be it already exist?
if not, would really be a +

Christophe

Le 28/03/2020 à 14:15, Mark Plas a écrit :

Hello Christian,

" I don’t really like the name,"

Maybe you could call it #tupleDo:?

                #(1 2 3) tupleDo: [:a :b :c | …]

Mark

Mark Plas

Software Engineer

T +32 2 467 34 30

[hidden email]

Nieuwe Gentsesteenweg 21/1

1702 Groot-Bijgaarden - Belgium

  www.mediagenix.tv

Directions to MEDIAGENIX

This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.

From: Esug-list [hidden email] On Behalf Of Christian Haider
Sent: zaterdag 28 maart 2020 13:43
To: [hidden email]; [hidden email]; [hidden email]
Subject: [Esug-list] destructDo:

Hi,

I am using a nice little method #destructDo: for a while now and it feels good.

In VisualWorks:

SequenceableCollection>>destructDo: aBlock

                                "Evaluate aBlock with the receiver's elements as parameters.

                                aBlock takes its arguments from the receiver.

                                'ok'

                                #(1 2 3) destructDo: [:a :b :c | a + b + c]

                                #(1 2 3) destructDo: [:a :b | a + b]

                                #(1 2 3) destructDo: [:a | a]

                                #(1 2 3) destructDo: [42]

                                'not ok'

                                #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]

                                "

                                ^aBlock cullWithArguments: self asArray

In Amber:

SequenceableCollection>>destructDo: aBlock

                                ^aBlock valueWithPossibleArguments: self

In Pharo and other dialects, I don’t know, but should be as easy.

For example you can do

                (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |

                               Date newDay: day monthNumber: month year: year]

I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.

Now the questions:

I am sure that others came up with this. Anybody knows?

What are you using for this pattern?

I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?

What are you thinking about this?

Happy hacking,

                Christian
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

dony.vcf (492 bytes) Download Attachment

Christian Haider

Re: destructDo:

Yes, that would be nice. Unfortunately a bit more involved than this 1-liner…

Von: Esug-list <[hidden email]> Im Auftrag von Christophe Dony
Gesendet: Samstag, 28. März 2020 15:17
An: [hidden email]
Betreff: Re: [Esug-list] destructDo:

Hello Christian,

" I don’t really like the name,"

Maybe you could call it #tupleDo:?

                #(1 2 3) tupleDo: [:a :b :c | …]

Mark

Mark Plas
Software Engineer
T +32 2 467 34 30
[hidden email]

Nieuwe Gentsesteenweg 21/1
1702 Groot-Bijgaarden - Belgium
  www.mediagenix.tv
Directions to MEDIAGENIX

This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.
From: Esug-list [hidden email] On Behalf Of Christian Haider
Sent: zaterdag 28 maart 2020 13:43
To: [hidden email]; [hidden email]; [hidden email]
Subject: [Esug-list] destructDo:

Hi,

I am using a nice little method #destructDo: for a while now and it feels good.
In VisualWorks:
SequenceableCollection>>destructDo: aBlock
                                "Evaluate aBlock with the receiver's elements as parameters.
                                aBlock takes its arguments from the receiver.
                                'ok'
                                #(1 2 3) destructDo: [:a :b :c | a + b + c]
                                #(1 2 3) destructDo: [:a :b | a + b]
                                #(1 2 3) destructDo: [:a | a]
                                #(1 2 3) destructDo: [42]
                                'not ok'
                                #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]
                                "
                                ^aBlock cullWithArguments: self asArray

In Amber:
SequenceableCollection>>destructDo: aBlock
                                ^aBlock valueWithPossibleArguments: self

In Pharo and other dialects, I don’t know, but should be as easy.

For example you can do
                (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |
                               Date newDay: day monthNumber: month year: year]

I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.

Now the questions:
I am sure that others came up with this. Anybody knows?
What are you using for this pattern?
I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
What are you thinking about this?

Happy hacking,
                Christian
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

Martin McClure-5

Re: destructDo:

Hi Christian and all,

#destructDo: is probably not the best name. "Destruct" can be interpreted as either short for "destructured" (which is what you want) or more like "destroy" as in "self-destruct." I initially took "destruct" in the "destroy" sense and guessed that #destructDo: might remove each element from the collection as it iterated. You could lengthen it to #destructured: or #destructuredDo:, but if there's a good short name that would be better.

#tupleDo: feels better.

But both #tupleDo: and #destructDo: contain "do" which implies iteration. Unless I'm missing something, your #destructDo: does not iterate. I'd really expect a #tupleDo: to iterate -- I'd expect with

#(1 2 3 4) tupleDo: [:a :b: | a + b]

that the block would be evaluated twice, once with 1 and 2 and once with 3 and 4. This would be a nice pattern; you could also have a tupleCollect: a tupleDetect: and so on.

#mapTo: is quite similar to #map: in PetitParser, except IIRC PetitParser's #map: expects an exact match in argument count. But maybe #map: is a good name for consistency.

Hope this helps.

Regards,
-Martin

On 3/28/20 7:24 AM, Christian Haider wrote:

Yes, that would be nice. Unfortunately a bit more involved than this 1-liner…

Von: Esug-list [hidden email] Im Auftrag von Christophe Dony
Gesendet: Samstag, 28. März 2020 15:17
An: [hidden email]
Betreff: Re: [Esug-list] destructDo:

Hi.
I like tupleDo:

or matchDo:

and what about installing a full pattern matching, as in many languages e.g. Scheme : https://docs.racket-lang.org/reference/match.html

#(1 #(2 3 6 7) 4) matchDo: [:a (:b :@c) :d] | …]
here c would be #(3 6 7)

may be it already exist?
if not, would really be a +

Christophe

Le 28/03/2020 à 14:15, Mark Plas a écrit :
Hello Christian,

" I don’t really like the name,"

Maybe you could call it #tupleDo:?

                #(1 2 3) tupleDo: [:a :b :c | …]

Mark

Mark Plas

Software Engineer

T +32 2 467 34 30

[hidden email]

Nieuwe Gentsesteenweg 21/1

1702 Groot-Bijgaarden - Belgium

  www.mediagenix.tv

Directions to MEDIAGENIX

This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.

From: Esug-list [hidden email] On Behalf Of Christian Haider
Sent: zaterdag 28 maart 2020 13:43
To: [hidden email]; [hidden email]; [hidden email]
Subject: [Esug-list] destructDo:

Hi,

I am using a nice little method #destructDo: for a while now and it feels good.

In VisualWorks:

SequenceableCollection>>destructDo: aBlock

                                "Evaluate aBlock with the receiver's elements as parameters.

                                aBlock takes its arguments from the receiver.

                                'ok'

                                #(1 2 3) destructDo: [:a :b :c | a + b + c]

                                #(1 2 3) destructDo: [:a :b | a + b]

                                #(1 2 3) destructDo: [:a | a]

                                #(1 2 3) destructDo: [42]

                                'not ok'

                                #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]

                                "

                                ^aBlock cullWithArguments: self asArray

In Amber:

SequenceableCollection>>destructDo: aBlock

                                ^aBlock valueWithPossibleArguments: self

In Pharo and other dialects, I don’t know, but should be as easy.

For example you can do

                (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |

                               Date newDay: day monthNumber: month year: year]

I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.

Now the questions:

I am sure that others came up with this. Anybody knows?

What are you using for this pattern?

I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?

What are you thinking about this?

Happy hacking,

                Christian
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

nrgiii

Re: destructDo:

I agree with Martin. The default connotation of 'destruct' in English is to destroy. I would suggest either #destructuredDo: or #tuppleDo: to avoid confusion.

Norm

On 3/28/2020 8:13 AM, Martin McClure wrote:

Hi Christian and all,

#destructDo: is probably not the best name. "Destruct" can be interpreted as either short for "destructured" (which is what you want) or more like "destroy" as in "self-destruct." I initially took "destruct" in the "destroy" sense and guessed that #destructDo: might remove each element from the collection as it iterated. You could lengthen it to #destructured: or #destructuredDo:, but if there's a good short name that would be better.

#tupleDo: feels better.

But both #tupleDo: and #destructDo: contain "do" which implies iteration. Unless I'm missing something, your #destructDo: does not iterate. I'd really expect a #tupleDo: to iterate -- I'd expect with

#(1 2 3 4) tupleDo: [:a :b: | a + b]

that the block would be evaluated twice, once with 1 and 2 and once with 3 and 4. This would be a nice pattern; you could also have a tupleCollect: a tupleDetect: and so on.

#mapTo: is quite similar to #map: in PetitParser, except IIRC PetitParser's #map: expects an exact match in argument count. But maybe #map: is a good name for consistency.

Hope this helps.

Regards,
-Martin

On 3/28/20 7:24 AM, Christian Haider wrote:
Yes, that would be nice. Unfortunately a bit more involved than this 1-liner…

Von: Esug-list [hidden email] Im Auftrag von Christophe Dony
Gesendet: Samstag, 28. März 2020 15:17
An: [hidden email]
Betreff: Re: [Esug-list] destructDo:

Hi.
I like tupleDo:

or matchDo:

and what about installing a full pattern matching, as in many languages e.g. Scheme : https://docs.racket-lang.org/reference/match.html

#(1 #(2 3 6 7) 4) matchDo: [:a (:b :@c) :d] | …]
here c would be #(3 6 7)

may be it already exist?
if not, would really be a +

Christophe

Le 28/03/2020 à 14:15, Mark Plas a écrit :
Hello Christian,

" I don’t really like the name,"

Maybe you could call it #tupleDo:?

                #(1 2 3) tupleDo: [:a :b :c | …]

Mark

Mark Plas

Software Engineer

T +32 2 467 34 30

[hidden email]

Nieuwe Gentsesteenweg 21/1

1702 Groot-Bijgaarden - Belgium

  www.mediagenix.tv

Directions to MEDIAGENIX

This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.

From: Esug-list [hidden email] On Behalf Of Christian Haider
Sent: zaterdag 28 maart 2020 13:43
To: [hidden email]; [hidden email]; [hidden email]
Subject: [Esug-list] destructDo:

Hi,

I am using a nice little method #destructDo: for a while now and it feels good.

In VisualWorks:

SequenceableCollection>>destructDo: aBlock

                                "Evaluate aBlock with the receiver's elements as parameters.

                                aBlock takes its arguments from the receiver.

                                'ok'

                                #(1 2 3) destructDo: [:a :b :c | a + b + c]

                                #(1 2 3) destructDo: [:a :b | a + b]

                                #(1 2 3) destructDo: [:a | a]

                                #(1 2 3) destructDo: [42]

                                'not ok'

                                #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]

                                "

                                ^aBlock cullWithArguments: self asArray

In Amber:

SequenceableCollection>>destructDo: aBlock

                                ^aBlock valueWithPossibleArguments: self

In Pharo and other dialects, I don’t know, but should be as easy.

For example you can do

                (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |

                               Date newDay: day monthNumber: month year: year]

I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.

Now the questions:

I am sure that others came up with this. Anybody knows?

What are you using for this pattern?

I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?

What are you thinking about this?

Happy hacking,

                Christian
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

CyrilFerlicot

Re: destructDo:

In reply to this post by NorbertHartl

Le 28/03/2020 à 13:42, Christian Haider a écrit :

> Hi,
>
>
>
> I am using a nice little method #destructDo: for a while now and it
> feels good.
>
> In VisualWorks:
>
> SequenceableCollection>>destructDo: aBlock
>
>                                 "Evaluate aBlock with the receiver's
> elements as parameters.
>
>                                 aBlock takes its arguments from the
> receiver.
>
>                                 'ok'
>
>                                 #(1 2 3) destructDo: [:a :b :c | a + b + c]
>
>                                 #(1 2 3) destructDo: [:a :b | a + b]
>
>                                 #(1 2 3) destructDo: [:a | a]
>
>                                 #(1 2 3) destructDo: [42]
>
>                                 'not ok'
>
>                                 #(1 2 3) destructDo: [:a :b :c :d | a +
> b + c + d]
>
>                                 "
>
>                                 ^aBlock cullWithArguments: self asArray
>
>
>
> In Amber:
>
> SequenceableCollection>>destructDo: aBlock
>
>                                 ^aBlock valueWithPossibleArguments: self
>
>
>
> In Pharo and other dialects, I don’t know, but should be as easy.
>
>
>
> For example you can do
>
>                 (('2020-03-28' tokensBasedOn: $-) collect: #asNumber)
> destructDo: [:year :month :day |
>
>                                Date newDay: day monthNumber: month year:
> year]
>
>
>
> I like that the block is not the receiver (like with #valueWithArguments
> or #cullWithArguments), but the last argument.
>
>
>
> Now the questions:
>
> * I am sure that others came up with this. Anybody knows?
> * What are you using for this pattern?
> * I don’t really like the name, but haven’t found anything better yet.
> Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe
> something shorter? Ideas?
> * What are you thinking about this?
>
>
>
> Happy hacking,
>
>                 Christian
>
>

Hi Christian,

In Pharo 8 was introduced a #bind method that seems similar to what you do:

SequenceableCollection>>bind: aBlock

"Extract items from the receiver and use them as argumeents of aBlock.
Signal an error
(ArgumentsCountMismatch) when the arguments count of aBlock does not
match the receiver size."

"(#(1 2 3) bind: [ :first :second :third | first + second + third ]) >>> 6"

^ aBlock valueWithArguments: self

The difference is that arguments are not optionals but I think it would
be cool to make them optional in this #bind: method.

>
>
> _______________________________________________
> Esug-list mailing list
> [hidden email]
> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
>

--
Cyril Ferlicot
https://ferlicot.fr

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

signature.asc (836 bytes) Download Attachment

fniephaus

Re: destructDo:

In reply to this post by nrgiii

On Sat, 28 Mar 2020 at 5:00 pm, Norm Green <[hidden email]> wrote:

I agree with Martin. The default connotation of 'destruct' in English is to destroy. I would suggest either #destructuredDo: or #tuppleDo: to avoid confusion.

I agree. How about this:

#(1 2 3 4) feedInto: [:a :b: | a + b]

Cheers,

Fabio

Norm

On 3/28/2020 8:13 AM, Martin McClure wrote:
Hi Christian and all,

#destructDo: is probably not the best name. "Destruct" can be interpreted as either short for "destructured" (which is what you want) or more like "destroy" as in "self-destruct." I initially took "destruct" in the "destroy" sense and guessed that #destructDo: might remove each element from the collection as it iterated. You could lengthen it to #destructured: or #destructuredDo:, but if there's a good short name that would be better.

#tupleDo: feels better.

But both #tupleDo: and #destructDo: contain "do" which implies iteration. Unless I'm missing something, your #destructDo: does not iterate. I'd really expect a #tupleDo: to iterate -- I'd expect with

#(1 2 3 4) tupleDo: [:a :b: | a + b]

that the block would be evaluated twice, once with 1 and 2 and once with 3 and 4. This would be a nice pattern; you could also have a tupleCollect: a tupleDetect: and so on.

#mapTo: is quite similar to #map: in PetitParser, except IIRC PetitParser's #map: expects an exact match in argument count. But maybe #map: is a good name for consistency.

Hope this helps.

Regards,
-Martin

On 3/28/20 7:24 AM, Christian Haider wrote:
Yes, that would be nice. Unfortunately a bit more involved than this 1-liner…

Von: Esug-list [hidden email] Im Auftrag von Christophe Dony
Gesendet: Samstag, 28. März 2020 15:17
An: [hidden email]
Betreff: Re: [Esug-list] destructDo:

Hi.
I like tupleDo:

or matchDo:

and what about installing a full pattern matching, as in many languages e.g. Scheme : https://docs.racket-lang.org/reference/match.html

#(1 #(2 3 6 7) 4) matchDo: [:a (:b :@c) :d] | …]
here c would be #(3 6 7)

may be it already exist?
if not, would really be a +

Christophe

Le 28/03/2020 à 14:15, Mark Plas a écrit :
Hello Christian,

" I don’t really like the name,"

Maybe you could call it #tupleDo:?

                #(1 2 3) tupleDo: [:a :b :c | …]

Mark

Mark Plas

Software Engineer

T +32 2 467 34 30

[hidden email]

Nieuwe Gentsesteenweg 21/1

1702 Groot-Bijgaarden - Belgium

  www.mediagenix.tv

Directions to MEDIAGENIX

This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.

From: Esug-list [hidden email] On Behalf Of Christian Haider
Sent: zaterdag 28 maart 2020 13:43
To: [hidden email]; [hidden email]; [hidden email]
Subject: [Esug-list] destructDo:

Hi,

I am using a nice little method #destructDo: for a while now and it feels good.

In VisualWorks:

SequenceableCollection>>destructDo: aBlock

                                "Evaluate aBlock with the receiver's elements as parameters.

                                aBlock takes its arguments from the receiver.

                                'ok'

                                #(1 2 3) destructDo: [:a :b :c | a + b + c]

                                #(1 2 3) destructDo: [:a :b | a + b]

                                #(1 2 3) destructDo: [:a | a]

                                #(1 2 3) destructDo: [42]

                                'not ok'

                                #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]

                                "

                                ^aBlock cullWithArguments: self asArray

In Amber:

SequenceableCollection>>destructDo: aBlock

                                ^aBlock valueWithPossibleArguments: self

In Pharo and other dialects, I don’t know, but should be as easy.

For example you can do

                (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |

                               Date newDay: day monthNumber: month year: year]

I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.

Now the questions:

I am sure that others came up with this. Anybody knows?

What are you using for this pattern?

I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?

What are you thinking about this?

Happy hacking,

                Christian
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

Christian Haider

Re: destructDo:

In reply to this post by CyrilFerlicot

Yes, exactly the same idea. Cool!

-----Ursprüngliche Nachricht-----
Von: Esug-list <[hidden email]> Im Auftrag von Cyril
Ferlicot D.
Gesendet: Samstag, 28. März 2020 17:02
An: [hidden email]
Betreff: Re: [Esug-list] destructDo:

Le 28/03/2020 à 13:42, Christian Haider a écrit :

> Hi,
>
>
>
> I am using a nice little method #destructDo: for a while now and it
> feels good.
>
> In VisualWorks:
>
> SequenceableCollection>>destructDo: aBlock
>
>                                 "Evaluate aBlock with the receiver's
> elements as parameters.
>
>                                 aBlock takes its arguments from the
> receiver.
>
>                                 'ok'
>
>                                 #(1 2 3) destructDo: [:a :b :c | a + b
> + c]
>
>                                 #(1 2 3) destructDo: [:a :b | a + b]
>
>                                 #(1 2 3) destructDo: [:a | a]
>
>                                 #(1 2 3) destructDo: [42]
>
>                                 'not ok'
>
>                                 #(1 2 3) destructDo: [:a :b :c :d | a
> + b + c + d]
>
>                                 "
>
>                                 ^aBlock cullWithArguments: self
> asArray
>
>
>
> In Amber:
>
> SequenceableCollection>>destructDo: aBlock
>
>                                 ^aBlock valueWithPossibleArguments:
> self
>
>
>
> In Pharo and other dialects, I dont know, but should be as easy.
>
>
>
> For example you can do
>
>                 (('2020-03-28' tokensBasedOn: $-) collect: #asNumber)
> destructDo: [:year :month :day |
>
>                                Date newDay: day monthNumber: month year:
> year]
>
>
>
> I like that the block is not the receiver (like with
> #valueWithArguments or #cullWithArguments), but the last argument.
>
>
>
> Now the questions:
>
> * I am sure that others came up with this. Anybody knows?
> * What are you using for this pattern?
> * I dont really like the name, but havent found anything better yet.
> Maybe #destructedDo: or just #destructed: or: #withPartsDo: maybe
> something shorter? Ideas?
> * What are you thinking about this?
>
>
>
> Happy hacking,
>
>                 Christian
>
>

Hi Christian,

In Pharo 8 was introduced a #bind method that seems similar to what you do:

SequenceableCollection>>bind: aBlock

"Extract items from the receiver and use them as argumeents of
aBlock.
Signal an error
(ArgumentsCountMismatch) when the arguments count of aBlock does not
match the receiver size."

"(#(1 2 3) bind: [ :first :second :third | first + second + third ])
>>> 6"

^ aBlock valueWithArguments: self

The difference is that arguments are not optionals but I think it would be
cool to make them optional in this #bind: method.

>
>
> _______________________________________________
> Esug-list mailing list
> [hidden email]
> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
>

--
Cyril Ferlicot
https://ferlicot.fr

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

Christian Haider

Re: destructDo:

In reply to this post by fniephaus

(somehow, I didn’t get Martins mail)

Yes, Martin, I agree with the misleading xDo: connotation. Thanks for your nice deconstruction of what I wanted J.

Cyril suggests #bind:, which does not feel fully right.

How about #boundTo: ? #(1 2 3) boundTo: [:a :b :c | …]

Happy hacking,

Christian

Von: Esug-list <[hidden email]> Im Auftrag von Fabio Niephaus
Gesendet: Samstag, 28. März 2020 17:04
An: [hidden email]
Betreff: Re: [Esug-list] destructDo:

On Sat, 28 Mar 2020 at 5:00 pm, Norm Green <[hidden email]> wrote:

I agree with Martin. The default connotation of 'destruct' in English is to destroy. I would suggest either #destructuredDo: or #tuppleDo: to avoid confusion.

I agree. How about this:

#(1 2 3 4) feedInto: [:a :b: | a + b]

Cheers,

Fabio

Norm

On 3/28/2020 8:13 AM, Martin McClure wrote:
Hi Christian and all,

#destructDo: is probably not the best name. "Destruct" can be interpreted as either short for "destructured" (which is what you want) or more like "destroy" as in "self-destruct." I initially took "destruct" in the "destroy" sense and guessed that #destructDo: might remove each element from the collection as it iterated. You could lengthen it to #destructured: or #destructuredDo:, but if there's a good short name that would be better.

#tupleDo: feels better.

But both #tupleDo: and #destructDo: contain "do" which implies iteration. Unless I'm missing something, your #destructDo: does not iterate. I'd really expect a #tupleDo: to iterate -- I'd expect with

#(1 2 3 4) tupleDo: [:a :b: | a + b]

that the block would be evaluated twice, once with 1 and 2 and once with 3 and 4. This would be a nice pattern; you could also have a tupleCollect: a tupleDetect: and so on.

#mapTo: is quite similar to #map: in PetitParser, except IIRC PetitParser's #map: expects an exact match in argument count. But maybe #map: is a good name for consistency.

Hope this helps.

Regards,
-Martin

On 3/28/20 7:24 AM, Christian Haider wrote:
Yes, that would be nice. Unfortunately a bit more involved than this 1-liner…

Von: Esug-list [hidden email] Im Auftrag von Christophe Dony
Gesendet: Samstag, 28. März 2020 15:17
An: [hidden email]
Betreff: Re: [Esug-list] destructDo:

Hi.
I like tupleDo:

or matchDo:

and what about installing a full pattern matching, as in many languages e.g. Scheme : https://docs.racket-lang.org/reference/match.html

#(1 #(2 3 6 7) 4) matchDo: [:a (:b :@c) :d] | …]
here c would be #(3 6 7)

may be it already exist?
if not, would really be a +

Christophe

Le 28/03/2020 à 14:15, Mark Plas a écrit :
Hello Christian,

" I don’t really like the name,"

Maybe you could call it #tupleDo:?

                #(1 2 3) tupleDo: [:a :b :c | …]

Mark

Mark Plas
Software Engineer
T +32 2 467 34 30
[hidden email]

Nieuwe Gentsesteenweg 21/1
1702 Groot-Bijgaarden - Belgium
  www.mediagenix.tv
Directions to MEDIAGENIX

This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.
From: Esug-list [hidden email] On Behalf Of Christian Haider
Sent: zaterdag 28 maart 2020 13:43
To: [hidden email]; [hidden email]; [hidden email]
Subject: [Esug-list] destructDo:

Hi,

I am using a nice little method #destructDo: for a while now and it feels good.
In VisualWorks:
SequenceableCollection>>destructDo: aBlock
                                "Evaluate aBlock with the receiver's elements as parameters.
                                aBlock takes its arguments from the receiver.
                                'ok'
                                #(1 2 3) destructDo: [:a :b :c | a + b + c]
                                #(1 2 3) destructDo: [:a :b | a + b]
                                #(1 2 3) destructDo: [:a | a]
                                #(1 2 3) destructDo: [42]
                                'not ok'
                                #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]
                                "
                                ^aBlock cullWithArguments: self asArray

In Amber:
SequenceableCollection>>destructDo: aBlock
                                ^aBlock valueWithPossibleArguments: self

In Pharo and other dialects, I don’t know, but should be as easy.

For example you can do
                (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |
                               Date newDay: day monthNumber: month year: year]

I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.

Now the questions:
I am sure that others came up with this. Anybody knows?
What are you using for this pattern?
I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
What are you thinking about this?

Happy hacking,
                Christian
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

Pape, Tobias

Re: destructDo:

In reply to this post by fniephaus

> On 28.03.2020, at 17:04, Fabio Niephaus <[hidden email]> wrote:
>
>
>
> On Sat, 28 Mar 2020 at 5:00 pm, Norm Green <[hidden email]> wrote:
> I agree with Martin. The default connotation of 'destruct' in English is to destroy. I would suggest either #destructuredDo: or #tuppleDo: to avoid confusion.
>
> I agree. How about this:
>
>> #(1 2 3 4) feedInto: [:a :b: | a + b]
>

Or `#(1 2 3 4) partsIn: [:a :b | a + b]`

Best regards
-Tobias

> Cheers,
> Fabio
>
>
>
> Norm
>
>
> On 3/28/2020 8:13 AM, Martin McClure wrote:
>> Hi Christian and all,
>>
>> #destructDo: is probably not the best name. "Destruct" can be interpreted as either short for "destructured" (which is what you want) or more like "destroy" as in "self-destruct." I initially took "destruct" in the "destroy" sense and guessed that #destructDo: might remove each element from the collection as it iterated. You could lengthen it to #destructured: or #destructuredDo:, but if there's a good short name that would be better.
>>
>> #tupleDo: feels better.
>>
>> But both #tupleDo: and #destructDo: contain "do" which implies iteration. Unless I'm missing something, your #destructDo: does not iterate. I'd really expect a #tupleDo: to iterate -- I'd expect with
>>
>> #(1 2 3 4) tupleDo: [:a :b: | a + b]
>>
>> that the block would be evaluated twice, once with 1 and 2 and once with 3 and 4. This would be a nice pattern; you could also have a tupleCollect: a tupleDetect: and so on.
>>
>> #mapTo: is quite similar to #map: in PetitParser, except IIRC PetitParser's #map: expects an exact match in argument count. But maybe #map: is a good name for consistency.
>>
>> Hope this helps.
>>
>> Regards,
>> -Martin
>>
>> On 3/28/20 7:24 AM, Christian Haider wrote:
>>> Yes, that would be nice. Unfortunately a bit more involved than this 1-liner…
>>>
>>>
>>>
>>> Von: Esug-list <[hidden email]> Im Auftrag von Christophe Dony
>>> Gesendet: Samstag, 28. März 2020 15:17
>>> An: [hidden email]
>>> Betreff: Re: [Esug-list] destructDo:
>>>
>>>
>>>
>>> Hi.
>>> I like tupleDo:
>>>
>>> or matchDo:
>>>
>>> and what about installing a full pattern matching, as in many languages e.g. Scheme : https://docs.racket-lang.org/reference/match.html
>>>
>>> #(1 #(2 3 6 7) 4) matchDo: [:a (:b :@c) :d] | …]
>>> here c would be #(3 6 7)
>>>
>>> may be it already exist?
>>> if not, would really be a +
>>>
>>> Christophe
>>>
>>>
>>>
>>> Le 28/03/2020 à 14:15, Mark Plas a écrit :
>>>
>>> Hello Christian,
>>>
>>>
>>>
>>> " I don’t really like the name,"
>>>
>>>
>>>
>>> Maybe you could call it #tupleDo:?
>>>
>>>
>>>
>>> #(1 2 3) tupleDo: [:a :b :c | …]
>>>
>>>
>>>
>>> Mark
>>>
>>>
>>>
>>>
>>>
>>> Mark Plas
>>>
>>> Software Engineer
>>>
>>> T +32 2 467 34 30
>>>
>>> [hidden email]
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>> Nieuwe Gentsesteenweg 21/1
>>>
>>>
>>> 1702 Groot-Bijgaarden - Belgium
>>>
>>>
>>> www.mediagenix.tv
>>>
>>>
>>> Directions to MEDIAGENIX
>>>
>>>
>>>
>>>
>>> This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.
>>>
>>> From: Esug-list <[hidden email]> On Behalf Of Christian Haider
>>> Sent: zaterdag 28 maart 2020 13:43
>>> To: [hidden email]; [hidden email]; [hidden email]
>>> Subject: [Esug-list] destructDo:
>>>
>>>
>>>
>>> Hi,
>>>
>>>
>>>
>>> I am using a nice little method #destructDo: for a while now and it feels good.
>>>
>>> In VisualWorks:
>>>
>>> SequenceableCollection>>destructDo: aBlock
>>>
>>> "Evaluate aBlock with the receiver's elements as parameters.
>>>
>>> aBlock takes its arguments from the receiver.
>>>
>>> 'ok'
>>>
>>> #(1 2 3) destructDo: [:a :b :c | a + b + c]
>>>
>>> #(1 2 3) destructDo: [:a :b | a + b]
>>>
>>> #(1 2 3) destructDo: [:a | a]
>>>
>>> #(1 2 3) destructDo: [42]
>>>
>>> 'not ok'
>>>
>>> #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]
>>>
>>> "
>>>
>>> ^aBlock cullWithArguments: self asArray
>>>
>>>
>>>
>>> In Amber:
>>>
>>> SequenceableCollection>>destructDo: aBlock
>>>
>>> ^aBlock valueWithPossibleArguments: self
>>>
>>>
>>>
>>> In Pharo and other dialects, I don’t know, but should be as easy.
>>>
>>>
>>>
>>> For example you can do
>>>
>>> (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |
>>>
>>> Date newDay: day monthNumber: month year: year]
>>>
>>>
>>>
>>> I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.
>>>
>>>
>>>
>>> Now the questions:
>>>
>>> • I am sure that others came up with this. Anybody knows?
>>> • What are you using for this pattern?
>>> • I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
>>> • What are you thinking about this?
>>>
>>>
>>> Happy hacking,
>>>
>>> Christian
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>> _______________________________________________
>>> Esug-list mailing list
>>> [hidden email]
>>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
>>>
>>>
>>>
>>>
>>> _______________________________________________
>>> Esug-list mailing list
>>>
>>> [hidden email]
>>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
>>
>>
>>
>> _______________________________________________
>> Esug-list mailing list
>>
>> [hidden email]
>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
>
> _______________________________________________
> Esug-list mailing list
> [hidden email]
> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
> _______________________________________________
> Esug-list mailing list
> [hidden email]
> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

--
Tobias Pape
Software Architecture Group | http://www.hpi.uni-potsdam.de/swa/
Future SOC Lab | https://hpi.de/future-soc-lab

Hasso-Plattner-Institut für Digital Engineering gGmbH | Universität Potsdam
Prof.-Dr.-Helmert-Str. 2-3, D-14482 Potsdam, Germany
Amtsgericht Potsdam, HRB 12184 | Geschäftsführung: Prof. Dr. Christoph Meinel

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

bpi

Re: destructDo:

In reply to this post by Martin McClure-5

Hi everyone,

I find Martin's arguments regarding "destruct" and "do" rather convincing. Which brings me to:

#(1 2 3) destructured: [:a :b :c | a + b + c]

Christian, have you ever used this method in a case in which the number of block arguments was smaller than the receiver collection's size?

Bernhard

> Am 28.03.2020 um 16:13 schrieb Martin McClure <[hidden email]>:
>
> Hi Christian and all,
>
> #destructDo: is probably not the best name. "Destruct" can be interpreted as either short for "destructured" (which is what you want) or more like "destroy" as in "self-destruct." I initially took "destruct" in the "destroy" sense and guessed that #destructDo: might remove each element from the collection as it iterated. You could lengthen it to #destructured: or #destructuredDo:, but if there's a good short name that would be better.
>
> #tupleDo: feels better.
>
> But both #tupleDo: and #destructDo: contain "do" which implies iteration. Unless I'm missing something, your #destructDo: does not iterate. I'd really expect a #tupleDo: to iterate -- I'd expect with
>
> #(1 2 3 4) tupleDo: [:a :b: | a + b]
>
> that the block would be evaluated twice, once with 1 and 2 and once with 3 and 4. This would be a nice pattern; you could also have a tupleCollect: a tupleDetect: and so on.
>
> #mapTo: is quite similar to #map: in PetitParser, except IIRC PetitParser's #map: expects an exact match in argument count. But maybe #map: is a good name for consistency.
>
> Hope this helps.
>
> Regards,
> -Martin
>
> On 3/28/20 7:24 AM, Christian Haider wrote:
>> Yes, that would be nice. Unfortunately a bit more involved than this 1-liner…
>>
>> Von: Esug-list <[hidden email]> Im Auftrag von Christophe Dony
>> Gesendet: Samstag, 28. März 2020 15:17
>> An: [hidden email]
>> Betreff: Re: [Esug-list] destructDo:
>>
>> Hi.
>> I like tupleDo:
>>
>> or matchDo:
>>
>> and what about installing a full pattern matching, as in many languages e.g. Scheme : https://docs.racket-lang.org/reference/match.html
>>
>> #(1 #(2 3 6 7) 4) matchDo: [:a (:b :@c) :d] | …]
>> here c would be #(3 6 7)
>>
>> may be it already exist?
>> if not, would really be a +
>>
>> Christophe
>>
>>
>>
>> Le 28/03/2020 à 14:15, Mark Plas a écrit :
>> Hello Christian,
>>
>> " I don’t really like the name,"
>>
>> Maybe you could call it #tupleDo:?
>>
>> #(1 2 3) tupleDo: [:a :b :c | …]
>>
>> Mark
>>
>>
>>
>> Mark Plas
>>
>> Software Engineer
>> T +32 2 467 34 30
>> [hidden email]
>>
>>
>>
>> <image001.png>
>>
>>
>> Nieuwe Gentsesteenweg 21/1
>>
>> 1702 Groot-Bijgaarden - Belgium
>>
>>
>> <image002.png> <image003.png><image004.png>www.mediagenix.tv
>>
>>
>> Directions to MEDIAGENIX
>>
>>
>>
>> This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.
>>
>> From: Esug-list <[hidden email]> On Behalf Of Christian Haider
>> Sent: zaterdag 28 maart 2020 13:43
>> To: [hidden email]; [hidden email]; [hidden email]
>> Subject: [Esug-list] destructDo:
>>
>> Hi,
>>
>> I am using a nice little method #destructDo: for a while now and it feels good.
>> In VisualWorks:
>> SequenceableCollection>>destructDo: aBlock
>> "Evaluate aBlock with the receiver's elements as parameters.
>> aBlock takes its arguments from the receiver.
>> 'ok'
>> #(1 2 3) destructDo: [:a :b :c | a + b + c]
>> #(1 2 3) destructDo: [:a :b | a + b]
>> #(1 2 3) destructDo: [:a | a]
>> #(1 2 3) destructDo: [42]
>> 'not ok'
>> #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]
>> "
>> ^aBlock cullWithArguments: self asArray
>>
>> In Amber:
>> SequenceableCollection>>destructDo: aBlock
>> ^aBlock valueWithPossibleArguments: self
>>
>> In Pharo and other dialects, I don’t know, but should be as easy.
>>
>> For example you can do
>> (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |
>> Date newDay: day monthNumber: month year: year]
>>
>> I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.
>>
>> Now the questions:
>> • I am sure that others came up with this. Anybody knows?
>> • What are you using for this pattern?
>> • I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
>> • What are you thinking about this?
>>
>> Happy hacking,
>> Christian
>>
>>
>>
>>
>> _______________________________________________
>> Esug-list mailing list
>> [hidden email]
>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
>>
>>
>>
>>
>> _______________________________________________
>> Esug-list mailing list
>>
>> [hidden email]
>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

Christian Haider

Re: destructDo:

Hi Bernhard,

yes, it is very handy for csv tables. I deal a lot with them lately (budgets, CoViD19).
I read a line, separate the fields and use that list for #destructDo: .
Now I can just pick the first n columns I am interested in.
(Mostly, identifying information is in the first columns.)

Real world example:
^stringsOfLine destructDo: [:ignore :string2 :string3 :string4 |
self produktbereich: string2 profitcenter: string3 bezeichnung: string4]

I think that the code becomes much more readable.
Except the name ... :-)

Stay healthy,
Christian

-----Ursprüngliche Nachricht-----
Von: Bernhard Pieber <[hidden email]>
Gesendet: Samstag, 28. März 2020 18:53
An: Martin McClure <[hidden email]>
Cc: Christian Haider <[hidden email]>; Christophe Dony <[hidden email]>; [hidden email]
Betreff: Re: [Esug-list] destructDo:

Hi everyone,

I find Martin's arguments regarding "destruct" and "do" rather convincing. Which brings me to:

#(1 2 3) destructured: [:a :b :c | a + b + c]

Christian, have you ever used this method in a case in which the number of block arguments was smaller than the receiver collection's size?

Bernhard

> Am 28.03.2020 um 16:13 schrieb Martin McClure <[hidden email]>:
>
> Hi Christian and all,
>
> #destructDo: is probably not the best name. "Destruct" can be interpreted as either short for "destructured" (which is what you want) or more like "destroy" as in "self-destruct." I initially took "destruct" in the "destroy" sense and guessed that #destructDo: might remove each element from the collection as it iterated. You could lengthen it to #destructured: or #destructuredDo:, but if there's a good short name that would be better.
>
> #tupleDo: feels better.
>
> But both #tupleDo: and #destructDo: contain "do" which implies
> iteration. Unless I'm missing something, your #destructDo: does not
> iterate. I'd really expect a #tupleDo: to iterate -- I'd expect with
>
> #(1 2 3 4) tupleDo: [:a :b: | a + b]
>
> that the block would be evaluated twice, once with 1 and 2 and once with 3 and 4. This would be a nice pattern; you could also have a tupleCollect: a tupleDetect: and so on.
>
> #mapTo: is quite similar to #map: in PetitParser, except IIRC PetitParser's #map: expects an exact match in argument count. But maybe #map: is a good name for consistency.
>
> Hope this helps.
>
> Regards,
> -Martin
>
> On 3/28/20 7:24 AM, Christian Haider wrote:
>> Yes, that would be nice. Unfortunately a bit more involved than this
>> 1-liner…
>>
>> Von: Esug-list <[hidden email]> Im Auftrag von
>> Christophe Dony
>> Gesendet: Samstag, 28. März 2020 15:17
>> An: [hidden email]
>> Betreff: Re: [Esug-list] destructDo:
>>
>> Hi.
>> I like tupleDo:
>>
>> or matchDo:
>>
>> and what about installing a full pattern matching, as in many
>> languages e.g. Scheme :
>> https://docs.racket-lang.org/reference/match.html
>>
>> #(1 #(2 3 6 7) 4) matchDo: [:a (:b :@c) :d] | …] here c would be #(3
>> 6 7)
>>
>> may be it already exist?
>> if not, would really be a +
>>
>> Christophe
>>
>>
>>
>> Le 28/03/2020 à 14:15, Mark Plas a écrit :
>> Hello Christian,
>>
>> " I don’t really like the name,"
>>
>> Maybe you could call it #tupleDo:?
>>
>> #(1 2 3) tupleDo: [:a :b :c | …]
>>
>> Mark
>>
>>
>>
>> Mark Plas
>>
>> Software Engineer
>> T +32 2 467 34 30
>> [hidden email]
>>
>>
>>
>> <image001.png>
>>
>>
>> Nieuwe Gentsesteenweg 21/1
>>
>> 1702 Groot-Bijgaarden - Belgium
>>
>>
>> <image002.png> <image003.png><image004.png>www.mediagenix.tv
>>
>>
>> Directions to MEDIAGENIX
>>
>>
>>
>> This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.
>>
>> From: Esug-list <[hidden email]> On Behalf Of
>> Christian Haider
>> Sent: zaterdag 28 maart 2020 13:43
>> To: [hidden email]; [hidden email];
>> [hidden email]
>> Subject: [Esug-list] destructDo:
>>
>> Hi,
>>
>> I am using a nice little method #destructDo: for a while now and it feels good.
>> In VisualWorks:
>> SequenceableCollection>>destructDo: aBlock
>> "Evaluate aBlock with the receiver's elements as parameters.
>> aBlock takes its arguments from the receiver.
>> 'ok'
>> #(1 2 3) destructDo: [:a :b :c | a + b + c]
>> #(1 2 3) destructDo: [:a :b | a + b]
>> #(1 2 3) destructDo: [:a | a]
>> #(1 2 3) destructDo: [42]
>> 'not ok'
>> #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]
>> "
>> ^aBlock cullWithArguments: self
>> asArray
>>
>> In Amber:
>> SequenceableCollection>>destructDo: aBlock
>> ^aBlock valueWithPossibleArguments:
>> self
>>
>> In Pharo and other dialects, I don’t know, but should be as easy.
>>
>> For example you can do
>> (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |
>> Date newDay: day monthNumber: month
>> year: year]
>>
>> I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.
>>
>> Now the questions:
>> • I am sure that others came up with this. Anybody knows?
>> • What are you using for this pattern?
>> • I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
>> • What are you thinking about this?
>>
>> Happy hacking,
>> Christian
>>
>>
>>
>>
>> _______________________________________________
>> Esug-list mailing list
>> [hidden email]
>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
>>
>>
>>
>>
>> _______________________________________________
>> Esug-list mailing list
>>
>> [hidden email]
>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

Pape, Tobias

Re: destructDo:

> On 28.03.2020, at 19:20, Christian Haider <[hidden email]> wrote:
>
> Hi Bernhard,
>
> yes, it is very handy for csv tables. I deal a lot with them lately (budgets, CoViD19).
> I read a line, separate the fields and use that list for #destructDo: .
> Now I can just pick the first n columns I am interested in.
> (Mostly, identifying information is in the first columns.)
>
> Real world example:
> ^stringsOfLine destructDo: [:ignore :string2 :string3 :string4 |
> self produktbereich: string2 profitcenter: string3 bezeichnung: string4]
>
> I think that the code becomes much more readable.

What about

^stringsOfLine asComponentsIn: [:ignore :string2 :string3 :string4 |
self produktbereich: string2 profitcenter: string3 bezeichnung: string4]

?

Best regards
-Tobias

> Except the name ... :-)
>
> Stay healthy,
> Christian
>
> -----Ursprüngliche Nachricht-----
> Von: Bernhard Pieber <[hidden email]>
> Gesendet: Samstag, 28. März 2020 18:53
> An: Martin McClure <[hidden email]>
> Cc: Christian Haider <[hidden email]>; Christophe Dony <[hidden email]>; [hidden email]
> Betreff: Re: [Esug-list] destructDo:
>
> Hi everyone,
>
> I find Martin's arguments regarding "destruct" and "do" rather convincing. Which brings me to:
>
> #(1 2 3) destructured: [:a :b :c | a + b + c]
>
> Christian, have you ever used this method in a case in which the number of block arguments was smaller than the receiver collection's size?
>
> Bernhard
>
>> Am 28.03.2020 um 16:13 schrieb Martin McClure <[hidden email]>:
>>
>> Hi Christian and all,
>>
>> #destructDo: is probably not the best name. "Destruct" can be interpreted as either short for "destructured" (which is what you want) or more like "destroy" as in "self-destruct." I initially took "destruct" in the "destroy" sense and guessed that #destructDo: might remove each element from the collection as it iterated. You could lengthen it to #destructured: or #destructuredDo:, but if there's a good short name that would be better.
>>
>> #tupleDo: feels better.
>>
>> But both #tupleDo: and #destructDo: contain "do" which implies
>> iteration. Unless I'm missing something, your #destructDo: does not
>> iterate. I'd really expect a #tupleDo: to iterate -- I'd expect with
>>
>> #(1 2 3 4) tupleDo: [:a :b: | a + b]
>>
>> that the block would be evaluated twice, once with 1 and 2 and once with 3 and 4. This would be a nice pattern; you could also have a tupleCollect: a tupleDetect: and so on.
>>
>> #mapTo: is quite similar to #map: in PetitParser, except IIRC PetitParser's #map: expects an exact match in argument count. But maybe #map: is a good name for consistency.
>>
>> Hope this helps.
>>
>> Regards,
>> -Martin
>>
>> On 3/28/20 7:24 AM, Christian Haider wrote:
>>> Yes, that would be nice. Unfortunately a bit more involved than this
>>> 1-liner…
>>>
>>> Von: Esug-list <[hidden email]> Im Auftrag von
>>> Christophe Dony
>>> Gesendet: Samstag, 28. März 2020 15:17
>>> An: [hidden email]
>>> Betreff: Re: [Esug-list] destructDo:
>>>
>>> Hi.
>>> I like tupleDo:
>>>
>>> or matchDo:
>>>
>>> and what about installing a full pattern matching, as in many
>>> languages e.g. Scheme :
>>> https://docs.racket-lang.org/reference/match.html
>>>
>>> #(1 #(2 3 6 7) 4) matchDo: [:a (:b :@c) :d] | …] here c would be #(3
>>> 6 7)
>>>
>>> may be it already exist?
>>> if not, would really be a +
>>>
>>> Christophe
>>>
>>>
>>>
>>> Le 28/03/2020 à 14:15, Mark Plas a écrit :
>>> Hello Christian,
>>>
>>> " I don’t really like the name,"
>>>
>>> Maybe you could call it #tupleDo:?
>>>
>>> #(1 2 3) tupleDo: [:a :b :c | …]
>>>
>>> Mark
>>>
>>>
>>>
>>> Mark Plas
>>>
>>> Software Engineer
>>> T +32 2 467 34 30
>>> [hidden email]
>>>
>>>
>>>
>>> <image001.png>
>>>
>>>
>>> Nieuwe Gentsesteenweg 21/1
>>>
>>> 1702 Groot-Bijgaarden - Belgium
>>>
>>>
>>> <image002.png> <image003.png><image004.png>www.mediagenix.tv
>>>
>>>
>>> Directions to MEDIAGENIX
>>>
>>>
>>>
>>> This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.
>>>
>>> From: Esug-list <[hidden email]> On Behalf Of
>>> Christian Haider
>>> Sent: zaterdag 28 maart 2020 13:43
>>> To: [hidden email]; [hidden email];
>>> [hidden email]
>>> Subject: [Esug-list] destructDo:
>>>
>>> Hi,
>>>
>>> I am using a nice little method #destructDo: for a while now and it feels good.
>>> In VisualWorks:
>>> SequenceableCollection>>destructDo: aBlock
>>> "Evaluate aBlock with the receiver's elements as parameters.
>>> aBlock takes its arguments from the receiver.
>>> 'ok'
>>> #(1 2 3) destructDo: [:a :b :c | a + b + c]
>>> #(1 2 3) destructDo: [:a :b | a + b]
>>> #(1 2 3) destructDo: [:a | a]
>>> #(1 2 3) destructDo: [42]
>>> 'not ok'
>>> #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]
>>> "
>>> ^aBlock cullWithArguments: self
>>> asArray
>>>
>>> In Amber:
>>> SequenceableCollection>>destructDo: aBlock
>>> ^aBlock valueWithPossibleArguments:
>>> self
>>>
>>> In Pharo and other dialects, I don’t know, but should be as easy.
>>>
>>> For example you can do
>>> (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |
>>> Date newDay: day monthNumber: month
>>> year: year]
>>>
>>> I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.
>>>
>>> Now the questions:
>>> • I am sure that others came up with this. Anybody knows?
>>> • What are you using for this pattern?
>>> • I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
>>> • What are you thinking about this?
>>>
>>> Happy hacking,
>>> Christian
>>>
>>>
>>>
>>>
>>> _______________________________________________
>>> Esug-list mailing list
>>> [hidden email]
>>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
>>>
>>>
>>>
>>>
>>> _______________________________________________
>>> Esug-list mailing list
>>>
>>> [hidden email]
>>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
>
>
>
>
> _______________________________________________
> Esug-list mailing list
> [hidden email]
> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

bpi

Re: destructDo:

In reply to this post by Christian Haider

Hi Christian,

Thank you for the example. I like it (except for the need of ignore maybe).

So #bind: from Pharo 8 would not work in that case, right?

I see three possible semantics:
1. block arguments size must match receiver collection's size: like Pharo 8's #bind or PetitParsers's #map::
2. arguments size must be equal or less than receiver collection's size: like #destructDo:
3. Like 2 but with using rest of collection (like in Nobert's JavaScript example): could be #destructDo:rest:

Bernhard

> Am 28.03.2020 um 19:20 schrieb Christian Haider <[hidden email]>:
>
>
> Hi Bernhard,
>
> yes, it is very handy for csv tables. I deal a lot with them lately (budgets, CoViD19).
> I read a line, separate the fields and use that list for #destructDo: .
> Now I can just pick the first n columns I am interested in.
> (Mostly, identifying information is in the first columns.)
>
> Real world example:
> ^stringsOfLine destructDo: [:ignore :string2 :string3 :string4 |
> self produktbereich: string2 profitcenter: string3 bezeichnung: string4]
>
> I think that the code becomes much more readable.
> Except the name ... :-)
>
> Stay healthy,
> Christian
>
> -----Ursprüngliche Nachricht-----
> Von: Bernhard Pieber <[hidden email]>
> Gesendet: Samstag, 28. März 2020 18:53
> An: Martin McClure <[hidden email]>
> Cc: Christian Haider <[hidden email]>; Christophe Dony <[hidden email]>; [hidden email]
> Betreff: Re: [Esug-list] destructDo:
>
> Hi everyone,
>
> I find Martin's arguments regarding "destruct" and "do" rather convincing. Which brings me to:
>
> #(1 2 3) destructured: [:a :b :c | a + b + c]
>
> Christian, have you ever used this method in a case in which the number of block arguments was smaller than the receiver collection's size?
>
> Bernhard
>
>> Am 28.03.2020 um 16:13 schrieb Martin McClure <[hidden email]>:
>>
>> Hi Christian and all,
>>
>> #destructDo: is probably not the best name. "Destruct" can be interpreted as either short for "destructured" (which is what you want) or more like "destroy" as in "self-destruct." I initially took "destruct" in the "destroy" sense and guessed that #destructDo: might remove each element from the collection as it iterated. You could lengthen it to #destructured: or #destructuredDo:, but if there's a good short name that would be better.
>>
>> #tupleDo: feels better.
>>
>> But both #tupleDo: and #destructDo: contain "do" which implies
>> iteration. Unless I'm missing something, your #destructDo: does not
>> iterate. I'd really expect a #tupleDo: to iterate -- I'd expect with
>>
>> #(1 2 3 4) tupleDo: [:a :b: | a + b]
>>
>> that the block would be evaluated twice, once with 1 and 2 and once with 3 and 4. This would be a nice pattern; you could also have a tupleCollect: a tupleDetect: and so on.
>>
>> #mapTo: is quite similar to #map: in PetitParser, except IIRC PetitParser's #map: expects an exact match in argument count. But maybe #map: is a good name for consistency.
>>
>> Hope this helps.
>>
>> Regards,
>> -Martin
>>
>> On 3/28/20 7:24 AM, Christian Haider wrote:
>>> Yes, that would be nice. Unfortunately a bit more involved than this
>>> 1-liner…
>>>
>>> Von: Esug-list <[hidden email]> Im Auftrag von
>>> Christophe Dony
>>> Gesendet: Samstag, 28. März 2020 15:17
>>> An: [hidden email]
>>> Betreff: Re: [Esug-list] destructDo:
>>>
>>> Hi.
>>> I like tupleDo:
>>>
>>> or matchDo:
>>>
>>> and what about installing a full pattern matching, as in many
>>> languages e.g. Scheme :
>>> https://docs.racket-lang.org/reference/match.html
>>>
>>> #(1 #(2 3 6 7) 4) matchDo: [:a (:b :@c) :d] | …] here c would be #(3
>>> 6 7)
>>>
>>> may be it already exist?
>>> if not, would really be a +
>>>
>>> Christophe
>>>
>>>
>>>
>>> Le 28/03/2020 à 14:15, Mark Plas a écrit :
>>> Hello Christian,
>>>
>>> " I don’t really like the name,"
>>>
>>> Maybe you could call it #tupleDo:?
>>>
>>> #(1 2 3) tupleDo: [:a :b :c | …]
>>>
>>> Mark
>>>
>>>
>>>
>>> Mark Plas
>>>
>>> Software Engineer
>>> T +32 2 467 34 30
>>> [hidden email]
>>>
>>>
>>>
>>> <image001.png>
>>>
>>>
>>> Nieuwe Gentsesteenweg 21/1
>>>
>>> 1702 Groot-Bijgaarden - Belgium
>>>
>>>
>>> <image002.png> <image003.png><image004.png>www.mediagenix.tv
>>>
>>>
>>> Directions to MEDIAGENIX
>>>
>>>
>>>
>>> This e-mail and any files attached to it are confidential and intended only for the use of the individuals or entity to whom they are addressed. If you have received this e-mail in error, please notify the sender immediately.
>>>
>>> From: Esug-list <[hidden email]> On Behalf Of
>>> Christian Haider
>>> Sent: zaterdag 28 maart 2020 13:43
>>> To: [hidden email]; [hidden email];
>>> [hidden email]
>>> Subject: [Esug-list] destructDo:
>>>
>>> Hi,
>>>
>>> I am using a nice little method #destructDo: for a while now and it feels good.
>>> In VisualWorks:
>>> SequenceableCollection>>destructDo: aBlock
>>> "Evaluate aBlock with the receiver's elements as parameters.
>>> aBlock takes its arguments from the receiver.
>>> 'ok'
>>> #(1 2 3) destructDo: [:a :b :c | a + b + c]
>>> #(1 2 3) destructDo: [:a :b | a + b]
>>> #(1 2 3) destructDo: [:a | a]
>>> #(1 2 3) destructDo: [42]
>>> 'not ok'
>>> #(1 2 3) destructDo: [:a :b :c :d | a + b + c + d]
>>> "
>>> ^aBlock cullWithArguments: self
>>> asArray
>>>
>>> In Amber:
>>> SequenceableCollection>>destructDo: aBlock
>>> ^aBlock valueWithPossibleArguments:
>>> self
>>>
>>> In Pharo and other dialects, I don’t know, but should be as easy.
>>>
>>> For example you can do
>>> (('2020-03-28' tokensBasedOn: $-) collect: #asNumber) destructDo: [:year :month :day |
>>> Date newDay: day monthNumber: month
>>> year: year]
>>>
>>> I like that the block is not the receiver (like with #valueWithArguments or #cullWithArguments), but the last argument.
>>>
>>> Now the questions:
>>> • I am sure that others came up with this. Anybody knows?
>>> • What are you using for this pattern?
>>> • I don’t really like the name, but haven’t found anything better yet. Maybe #destructedDo: or just #destructed: or: #withPartsDo:… maybe something shorter? Ideas?
>>> • What are you thinking about this?
>>>
>>> Happy hacking,
>>> Christian
>>>
>>>
>>>
>>>
>>> _______________________________________________
>>> Esug-list mailing list
>>> [hidden email]
>>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
>>>
>>>
>>>
>>>
>>> _______________________________________________
>>> Esug-list mailing list
>>>
>>> [hidden email]
>>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
>
>
>

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

Bert Freudenberg

Re: destructDo:

In reply to this post by Pape, Tobias

On Sat, Mar 28, 2020 at 11:27 AM Pape, Tobias <[hidden email]> wrote:

What about

^stringsOfLine asComponentsIn: [:ignore :string2 :string3 :string4 |
self produktbereich: string2 profitcenter: string3 bezeichnung: string4]

?

Best regards
-Tobias

Agreed, "...In:" is better than "...Do" because the latter implies iteration in Smalltalk. (never mind ifNotNilDo: which broke the convention)

And since block arguments are called "arguments" how about

aCollection asArgumentsIn: [:arg1 :arg2 :arg3 | ... ]

- Bert -

PS: Happy Covid Bike Shedding ;)

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

Christian Haider

Re: destructDo:

Not bad! Captures the semantics nicely.

Just a bit long

Von: Esug-list <[hidden email]> Im Auftrag von Bert Freudenberg
Gesendet: Sonntag, 29. März 2020 00:12
An: [hidden email]
Betreff: Re: [Esug-list] destructDo:

On Sat, Mar 28, 2020 at 11:27 AM Pape, Tobias <[hidden email]> wrote:

What about

^stringsOfLine asComponentsIn: [:ignore :string2 :string3 :string4 |
self produktbereich: string2 profitcenter: string3 bezeichnung: string4]

?

Best regards
-Tobias

Agreed, "...In:" is better than "...Do" because the latter implies iteration in Smalltalk. (never mind ifNotNilDo: which broke the convention)

And since block arguments are called "arguments" how about

aCollection asArgumentsIn: [:arg1 :arg2 :arg3 | ... ]

- Bert -

PS: Happy Covid Bike Shedding ;)

_______________________________________________
Esug-list mailing list
[hidden email]
http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org