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

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

> On 28.03.2020, at 19:20, Christian Haider <christian.haider@smalltalked-visuals.com> 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 <bernhard@pieber.com> > Gesendet: Samstag, 28. März 2020 18:53 > An: Martin McClure <martin.mcclure@gemtalksystems.com> > Cc: Christian Haider <christian.haider@smalltalked-visuals.com>; Christophe Dony <dony@lirmm.fr>; esug-list@lists.esug.org > 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 <martin.mcclure@gemtalksystems.com>: >> >> 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 <esug-list-bounces@lists.esug.org> Im Auftrag von >>> Christophe Dony >>> Gesendet: Samstag, 28. März 2020 15:17 >>> An: esug-list@lists.esug.org >>> 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 >>> mark.plas@mediagenix.tv >>> >>> >>> >>> <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 <esug-list-bounces@lists.esug.org> On Behalf Of >>> Christian Haider >>> Sent: zaterdag 28 maart 2020 13:43 >>> To: vwnc@cs.uiuc.edu; esug-list@lists.esug.org; >>> amber-lang@googlegroups.com >>> 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 >>> Esug-list@lists.esug.org >>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org >>> >>> >>> >>> >>> _______________________________________________ >>> Esug-list mailing list >>> >>> Esug-list@lists.esug.org >>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org > > > > > _______________________________________________ > Esug-list mailing list > Esug-list@lists.esug.org > 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

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

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 <christian.haider@smalltalked-visuals.com>: > > > 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 <bernhard@pieber.com> > Gesendet: Samstag, 28. März 2020 18:53 > An: Martin McClure <martin.mcclure@gemtalksystems.com> > Cc: Christian Haider <christian.haider@smalltalked-visuals.com>; Christophe Dony <dony@lirmm.fr>; esug-list@lists.esug.org > 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 <martin.mcclure@gemtalksystems.com>: >> >> 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 <esug-list-bounces@lists.esug.org> Im Auftrag von >>> Christophe Dony >>> Gesendet: Samstag, 28. März 2020 15:17 >>> An: esug-list@lists.esug.org >>> 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 >>> mark.plas@mediagenix.tv >>> >>> >>> >>> <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 <esug-list-bounces@lists.esug.org> On Behalf Of >>> Christian Haider >>> Sent: zaterdag 28 maart 2020 13:43 >>> To: vwnc@cs.uiuc.edu; esug-list@lists.esug.org; >>> amber-lang@googlegroups.com >>> 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 >>> Esug-list@lists.esug.org >>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org >>> >>> >>> >>> >>> _______________________________________________ >>> Esug-list mailing list >>> >>> Esug-list@lists.esug.org >>> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org > > >

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

Hello Christian, the hint to Lisp is obvious. In Clojure (a modern Lisp-Dialect) destructuring (https://clojure.org/guides/destructuring) is used a lot. Johannes Am 28.03.2020 um 15:23 schrieb Christian Haider <christian.haider@smalltalked-visuals.com<mailto:christian.haider@smalltalked-visuals.com>>: I chose the name because of the old Lisp “destructuring-bind”. But this is more powerful, because it does tree matching. This is just shallow. I am not sure where the concept was invented first. It may have been Lisp. Von: Norbert Hartl <norbert@hartl.name<mailto:norbert@hartl.name>> Gesendet: Samstag, 28. März 2020 14:20 An: Mark Plas <mark.plas@mediagenix.tv<mailto:mark.plas@mediagenix.tv>> Cc: Christian Haider <christian.haider@smalltalked-visuals.com<mailto:christian.haider@smalltalked-visuals.com>>; vwnc@cs.uiuc.edu<mailto:vwnc@cs.uiuc.edu>; esug-list@lists.esug.org<mailto:esug-list@lists.esug.org>; amber-lang@googlegroups.com<mailto:amber-lang@googlegroups.com> Betreff: Re: [Esug-list] 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 <mark.plas@mediagenix.tv<mailto:mark.plas@mediagenix.tv>>: 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 mark.plas@mediagenix.tv<mailto:mark.plas@mediagenix.tv> <logomgxnew_3d44337b-2535-4d6a-9f5f-3fdd565513ca.png> Nieuwe Gentsesteenweg 21/1<https://www.google.com/maps/dir/?api=1&destination=50.872900,4.286429> 1702 Groot-Bijgaarden - Belgium<https://www.google.com/maps/dir/?api=1&destination=50.872900,4.286429> <linkedin_75b9c4f1-6a2b-497c-aab8-df56fe16b8e3.png><https://nl.linkedin.com/company/mediagenix-ng> <twitter_de4c3300-c6ab-4898-a962-b33ff662a322.png><https://twitter.com/mediagenix_tv><Facebook-icon_6bef7545-f54e-4548-bfc4-1f07407f2642.png><https://www.facebook.com/MEDIAGENIX/>www.mediagenix.tv<http://www.mediagenix.tv/> Directions to MEDIAGENIX<http://www.mediagenix.tv/wp-content/uploads/2017/08/Directions.pdf> 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 <esug-list-bounces@lists.esug.org<mailto:esug-list-bounces@lists.esug.org>> On Behalf Of Christian Haider Sent: zaterdag 28 maart 2020 13:43 To: vwnc@cs.uiuc.edu<mailto:vwnc@cs.uiuc.edu>; esug-list@lists.esug.org<mailto:esug-list@lists.esug.org>; amber-lang@googlegroups.com<mailto:amber-lang@googlegroups.com> 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 Esug-list@lists.esug.org<mailto:Esug-list@lists.esug.org> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org _______________________________________________ Esug-list mailing list Esug-list@lists.esug.org<mailto:Esug-list@lists.esug.org> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

     ^stringsOfLine asComponentsIn: [:ignore :string2 :string3 :string4

On Sat, Mar 28, 2020 at 11:27 AM Pape, Tobias <Tobias.Pape@hpi.de> 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 ;)

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

Not bad! Captures the semantics nicely. Just a bit long Von: Esug-list <esug-list-bounces@lists.esug.org> Im Auftrag von Bert Freudenberg Gesendet: Sonntag, 29. März 2020 00:12 An: esug-list@lists.esug.org Betreff: Re: [Esug-list] destructDo: On Sat, Mar 28, 2020 at 11:27 AM Pape, Tobias <Tobias.Pape@hpi.de <mailto:Tobias.Pape@hpi.de> > 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 ;)

Am Sonntag, 29. März 2020, 00:58:49 MEZ hat Christian Haider <christian.haider@smalltalked-visuals.com> Folgendes geschrieben:  

intention revealing trumps brevity Am Sonntag, 29. März 2020, 00:58:49 MEZ hat Christian Haider <christian.haider@smalltalked-visuals.com> Folgendes geschrieben: Not bad! Captures the semantics nicely. Just a bit long   Von: Esug-list <esug-list-bounces@lists.esug.org> Im Auftrag von Bert Freudenberg Gesendet: Sonntag, 29. März 2020 00:12 An: esug-list@lists.esug.org Betreff: Re: [Esug-list] destructDo:   On Sat, Mar 28, 2020 at 11:27 AM Pape, Tobias <Tobias.Pape@hpi.de> 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 Esug-list@lists.esug.org http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

Agree with intention revealing - #argumentsIn: would contract it a bit more (not sure the as strictly needed as we aren’t returning a result). And #argsIn: might be a bit too concise. Like this proposal though. Tim On Sun, 29 Mar 2020, at 2:28 PM, Helge Nowak via Esug-list wrote: > > intention revealing trumps brevity > > Am Sonntag, 29. März 2020, 00:58:49 MEZ hat Christian Haider <christian.haider@smalltalked-visuals.com> Folgendes geschrieben: > > > Not bad! Captures the semantics nicely. > Just a bit long > > > *Von:* Esug-list <esug-list-bounces@lists.esug.org> *Im Auftrag von *Bert Freudenberg > *Gesendet:* Sonntag, 29. März 2020 00:12 > *An:* esug-list@lists.esug.org > *Betreff:* Re: [Esug-list] destructDo: > > > On Sat, Mar 28, 2020 at 11:27 AM Pape, Tobias <Tobias.Pape@hpi.de> 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 > Esug-list@lists.esug.org > http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org > _______________________________________________ > Esug-list mailing list > Esug-list@lists.esug.org > http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org >

     ^stringsOfLine asComponentsIn: [:ignore :string2 :string3 :string4

We write code once, but read it many times. Given the relatively few times I would be using this (rather nice) thing, I'd be happy to type the full: asArgumentsIn: Christian, congratulations on coming up with something to get us all thinking and talking. Good timing too :-/ Very best wishes, Bruce On Sun, 29 Mar 2020 at 15:24, Tim Mackinnon <tim@testit.works> wrote: > Agree with intention revealing - #argumentsIn: would contract it a bit > more (not sure the as strictly needed as we aren’t returning a result). And > #argsIn: might be a bit too concise. > > Like this proposal though. > > Tim > > On Sun, 29 Mar 2020, at 2:28 PM, Helge Nowak via Esug-list wrote: > > > intention revealing trumps brevity > > Am Sonntag, 29. März 2020, 00:58:49 MEZ hat Christian Haider < > christian.haider@smalltalked-visuals.com> Folgendes geschrieben: > > > Not bad! Captures the semantics nicely. > > Just a bit long > > > > > *Von:* Esug-list <esug-list-bounces@lists.esug.org> *Im Auftrag von *Bert > Freudenberg > *Gesendet:* Sonntag, 29. März 2020 00:12 > *An:* esug-list@lists.esug.org > *Betreff:* Re: [Esug-list] destructDo: > > > > > On Sat, Mar 28, 2020 at 11:27 AM Pape, Tobias <Tobias.Pape@hpi.de> 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 > Esug-list@lists.esug.org > http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org > _______________________________________________ > Esug-list mailing list > Esug-list@lists.esug.org > http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org > > > _______________________________________________ > Esug-list mailing list > Esug-list@lists.esug.org > http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org >

 Agree with intention revealing - #argumentsIn: would contract it a
 bit more (not sure the as strictly needed as we aren’t returning a
 result). And #argsIn: might be a bit too concise.

 Like this proposal though.

 Tim

 On Sun, 29 Mar 2020, at 2:28 PM, Helge Nowak via Esug-list wrote:

 intention revealing trumps brevity

 Am Sonntag, 29. März 2020, 00:58:49 MEZ hat Christian Haider
 <christian.haider@smalltalked-visuals.com
 <mailto:christian.haider@smalltalked-visuals.com>> Folgendes
 geschrieben:


 Not bad! Captures the semantics nicely.

 Just a bit long



 *Von:* Esug-list <esug-list-bounces@lists.esug.org
 <mailto:esug-list-bounces@lists.esug.org>> *Im Auftrag von *Bert
 Freudenberg
 *Gesendet:* Sonntag, 29. März 2020 00:12
 *An:* esug-list@lists.esug.org <mailto:esug-list@lists.esug.org>
 *Betreff:* Re: [Esug-list] destructDo:



 On Sat, Mar 28, 2020 at 11:27 AM Pape, Tobias <Tobias.Pape@hpi.de
 <mailto:Tobias.Pape@hpi.de>> 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
 Esug-list@lists.esug.org <mailto:Esug-list@lists.esug.org>
 http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org
 _______________________________________________
 Esug-list mailing list
 Esug-list@lists.esug.org <mailto:Esug-list@lists.esug.org>
 http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

 _______________________________________________
 Esug-list mailing list
 Esug-list@lists.esug.org <mailto:Esug-list@lists.esug.org>
 http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

After thinking about this message some more, it seemed to me that it was easier to come up with a good intention-revealing name if the block were the receiver and the array were the argument. It would be some kind of #valueWithArguments: selector. So I looked to see whether there was already such a thing, and sure enough, in Pharo there is #valueWithPossibleArgs:. #valueWithPossibleArgs: will accept arrays (and I hope any SequenceableCollection) of any size -- trimming the end off if too large, padding with nils if too short. On the principle of "if it's easy to come up with a good name, the design is probably pretty good" could this possibly be a better solution? Regards, -Martin On 3/29/20 7:50 AM, Bruce Badger wrote: > We write code once, but read it many times.  Given the relatively few > times I would be using this (rather nice) thing, I'd be happy to type > the full: > > asArgumentsIn: > > Christian, congratulations on coming up with something to get us all > thinking and talking.  Good timing too :-/ > > Very best wishes, >   Bruce > > On Sun, 29 Mar 2020 at 15:24, Tim Mackinnon <tim@testit.works> wrote: > > Agree with intention revealing - #argumentsIn: would contract it a > bit more (not sure the as strictly needed as we aren’t returning a > result). And #argsIn: might be a bit too concise. > > Like this proposal though. > > Tim > > On Sun, 29 Mar 2020, at 2:28 PM, Helge Nowak via Esug-list wrote: >> >> intention revealing trumps brevity >> >> Am Sonntag, 29. März 2020, 00:58:49 MEZ hat Christian Haider >> <christian.haider@smalltalked-visuals.com >> <mailto:christian.haider@smalltalked-visuals.com>> Folgendes >> geschrieben: >> >> >> Not bad! Captures the semantics nicely. >> >> Just a bit long >> >> >> >> *Von:* Esug-list <esug-list-bounces@lists.esug.org >> <mailto:esug-list-bounces@lists.esug.org>> *Im Auftrag von *Bert >> Freudenberg >> *Gesendet:* Sonntag, 29. März 2020 00:12 >> *An:* esug-list@lists.esug.org <mailto:esug-list@lists.esug.org> >> *Betreff:* Re: [Esug-list] destructDo: >> >> >> >> On Sat, Mar 28, 2020 at 11:27 AM Pape, Tobias <Tobias.Pape@hpi.de >> <mailto:Tobias.Pape@hpi.de>> 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 >> Esug-list@lists.esug.org <mailto:Esug-list@lists.esug.org> >> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org >> _______________________________________________ >> Esug-list mailing list >> Esug-list@lists.esug.org <mailto:Esug-list@lists.esug.org> >> http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org >> > > _______________________________________________ > Esug-list mailing list > Esug-list@lists.esug.org <mailto:Esug-list@lists.esug.org> > http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org > > > _______________________________________________ > Esug-list mailing list > Esug-list@lists.esug.org > http://lists.esug.org/mailman/listinfo/esug-list_lists.esug.org

     ^stringsOfLine asComponentsIn: [:ignore :string2 :string3 :string4

If you’re looking for a short selector that doesn’t reveal meaning by using more words, I would borrow a term that is used elsewhere, like your “destructure”. Various programming language communities have terms like “expand”, “unpack”, “spread”, or “splat” for using a sequence as separate arguments. Maybe “spread” would work? - Bert - On Sat, Mar 28, 2020 at 16:58 Christian Haider < christian.haider@smalltalked-visuals.com> wrote: > Not bad! Captures the semantics nicely. > > Just a bit long > > > > *Von:* Esug-list <esug-list-bounces@lists.esug.org> *Im Auftrag von *Bert > Freudenberg > *Gesendet:* Sonntag, 29. März 2020 00:12 > *An:* esug-list@lists.esug.org > *Betreff:* Re: [Esug-list] destructDo: > > > > On Sat, Mar 28, 2020 at 11:27 AM Pape, Tobias <Tobias.Pape@hpi.de> 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 ;) > -- -- Dr. Bert Freudenberg 7275 Franklin Avenue #210 Los Angeles CA 90046 +1 (818) 482-3991