Smalltalk › Pharo › Pharo Smalltalk Users

looking for another iterator :)

_‹ Previous Topic Next Topic _›

Classic

List

Threaded

21 messages Options

Stephane Ducasse-3

looking for another iterator :)

Hi

I would like to iterate at max on a certain amount of elements in a collection.
And I was wondering if we have such iterator.

Stef

Ben Coman

Re: looking for another iterator :)

On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]> wrote:
> Hi
>
> I would like to iterate at max on a certain amount of elements in a collection.
> And I was wondering if we have such iterator.

I'm not clear what functionality your asking for. Could you present
it as code & result if you assumed the iterator you want was
available?

cheers -ben

Clément Béra

Re: looking for another iterator :)

I don't think we do. Do you need it on SequenceableCollection or HashedCollection too ?

Recently I was trying to iterate over the first N elements of a collection and since there was no #first:do: I used #from:to:do:. I guess you could use that too:

aCollection from: 1 to: (aCollection size min: 1000) do: aBlock

Which guarantees you iterate at max over 1000 elements. But that API is SequenceableCollection specific.

On Sun, Jan 21, 2018 at 11:44 AM, Ben Coman <[hidden email]> wrote:

On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]> wrote:
> Hi
>
> I would like to iterate at max on a certain amount of elements in a collection.
> And I was wondering if we have such iterator.

I'm not clear what functionality your asking for. Could you present
it as code & result if you assumed the iterator you want was
available?

cheers -ben

Clément Béra

Pharo consortium engineer

https://clementbera.wordpress.com/

Bâtiment B 40, avenue Halley 59650 Villeneuve d'Ascq

Stephane Ducasse-3

Re: looking for another iterator :)

Hi Ben and Clement

I have a collection (a dictionary in my case) and I want to get
maximum 5 bindings out of it and iterate on them.
I want keysAndValuesDo: or do: but only up to 5 elements.

aDict atMax: 5 do: [:each | ]

So I learned from:to:do:

aCollection atMax: 5 do: [:each | ]

Does it make sense?

Stef

On Sun, Jan 21, 2018 at 1:16 PM, Clément Bera <[hidden email]> wrote:

> I don't think we do. Do you need it on SequenceableCollection or
> HashedCollection too ?
>
> Recently I was trying to iterate over the first N elements of a collection
> and since there was no #first:do: I used #from:to:do:. I guess you could use
> that too:
>
> aCollection from: 1 to: (aCollection size min: 1000) do: aBlock
>
> Which guarantees you iterate at max over 1000 elements. But that API is
> SequenceableCollection specific.
>
> On Sun, Jan 21, 2018 at 11:44 AM, Ben Coman <[hidden email]> wrote:
>>
>> On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]>
>> wrote:
>> > Hi
>> >
>> > I would like to iterate at max on a certain amount of elements in a
>> > collection.
>> > And I was wondering if we have such iterator.
>>
>> I'm not clear what functionality your asking for. Could you present
>> it as code & result if you assumed the iterator you want was
>> available?
>>
>> cheers -ben
>>
>
>
>
> --
> Clément Béra
> Pharo consortium engineer
> https://clementbera.wordpress.com/
> Bâtiment B 40, avenue Halley 59650 Villeneuve d'Ascq

Stephane Ducasse-3

Re: looking for another iterator :)

I thought about something like that...

SequenceableCollection >> atMax: numberOfItems do: aBlock
"Execute the iteration with at the maximum numberOfItems. If the
receiver contains less than numberOfItems iterate them all."
1 to: (numberOfItems min: self size) do: [:index | aBlock value:
(self at: index)]

This is an abstraction that we need to treat some samples.

Stef

On Sun, Jan 21, 2018 at 5:47 PM, Stephane Ducasse
<[hidden email]> wrote:

> Hi Ben and Clement
>
> I have a collection (a dictionary in my case) and I want to get
> maximum 5 bindings out of it and iterate on them.
> I want keysAndValuesDo: or do: but only up to 5 elements.
>
> aDict atMax: 5 do: [:each | ]
>
> So I learned from:to:do:
>
> aCollection atMax: 5 do: [:each | ]
>
> Does it make sense?
>
> Stef
>
> On Sun, Jan 21, 2018 at 1:16 PM, Clément Bera <[hidden email]> wrote:
>> I don't think we do. Do you need it on SequenceableCollection or
>> HashedCollection too ?
>>
>> Recently I was trying to iterate over the first N elements of a collection
>> and since there was no #first:do: I used #from:to:do:. I guess you could use
>> that too:
>>
>> aCollection from: 1 to: (aCollection size min: 1000) do: aBlock
>>
>> Which guarantees you iterate at max over 1000 elements. But that API is
>> SequenceableCollection specific.
>>
>> On Sun, Jan 21, 2018 at 11:44 AM, Ben Coman <[hidden email]> wrote:
>>>
>>> On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]>
>>> wrote:
>>> > Hi
>>> >
>>> > I would like to iterate at max on a certain amount of elements in a
>>> > collection.
>>> > And I was wondering if we have such iterator.
>>>
>>> I'm not clear what functionality your asking for. Could you present
>>> it as code & result if you assumed the iterator you want was
>>> available?
>>>
>>> cheers -ben
>>>
>>
>>
>>
>> --
>> Clément Béra
>> Pharo consortium engineer
>> https://clementbera.wordpress.com/
>> Bâtiment B 40, avenue Halley 59650 Villeneuve d'Ascq

Stephane Ducasse-3

Re: looking for another iterator :)

Now an iterator getting atMax: x elements could be better because we
could them combined it with collect:, detect:...

Stef

On Sun, Jan 21, 2018 at 5:56 PM, Stephane Ducasse
<[hidden email]> wrote:

> I thought about something like that...
>
> SequenceableCollection >> atMax: numberOfItems do: aBlock
> "Execute the iteration with at the maximum numberOfItems. If the
> receiver contains less than numberOfItems iterate them all."
> 1 to: (numberOfItems min: self size) do: [:index | aBlock value:
> (self at: index)]
>
> This is an abstraction that we need to treat some samples.
>
> Stef
>
> On Sun, Jan 21, 2018 at 5:47 PM, Stephane Ducasse
> <[hidden email]> wrote:
>> Hi Ben and Clement
>>
>> I have a collection (a dictionary in my case) and I want to get
>> maximum 5 bindings out of it and iterate on them.
>> I want keysAndValuesDo: or do: but only up to 5 elements.
>>
>> aDict atMax: 5 do: [:each | ]
>>
>> So I learned from:to:do:
>>
>> aCollection atMax: 5 do: [:each | ]
>>
>> Does it make sense?
>>
>> Stef
>>
>> On Sun, Jan 21, 2018 at 1:16 PM, Clément Bera <[hidden email]> wrote:
>>> I don't think we do. Do you need it on SequenceableCollection or
>>> HashedCollection too ?
>>>
>>> Recently I was trying to iterate over the first N elements of a collection
>>> and since there was no #first:do: I used #from:to:do:. I guess you could use
>>> that too:
>>>
>>> aCollection from: 1 to: (aCollection size min: 1000) do: aBlock
>>>
>>> Which guarantees you iterate at max over 1000 elements. But that API is
>>> SequenceableCollection specific.
>>>
>>> On Sun, Jan 21, 2018 at 11:44 AM, Ben Coman <[hidden email]> wrote:
>>>>
>>>> On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]>
>>>> wrote:
>>>> > Hi
>>>> >
>>>> > I would like to iterate at max on a certain amount of elements in a
>>>> > collection.
>>>> > And I was wondering if we have such iterator.
>>>>
>>>> I'm not clear what functionality your asking for. Could you present
>>>> it as code & result if you assumed the iterator you want was
>>>> available?
>>>>
>>>> cheers -ben
>>>>
>>>
>>>
>>>
>>> --
>>> Clément Béra
>>> Pharo consortium engineer
>>> https://clementbera.wordpress.com/
>>> Bâtiment B 40, avenue Halley 59650 Villeneuve d'Ascq

Ben Coman

Re: looking for another iterator :)

In reply to this post by Stephane Ducasse-3

On 22 January 2018 at 00:47, Stephane Ducasse <[hidden email]> wrote:

Just some random thoughts. Perhaps something more generic...

aDict doN: [ :each :n | aCollection add: each]
while: [ :each :n | n <=5 ]

For #select: & #collect: there is a distinction to make whether it is
5 elements processed
or 5 elements returned.

aDict select: [ :each | "do something" ]
while:
[ :iterator | iterator selectedCount <= 5 ]. "or..."
[ :iterator | iterator processedCount <= 5 ]. "or..."
[ :iterator | (iterator element ~= "breakElement")

cheers -ben

> Stef
>
> On Sun, Jan 21, 2018 at 1:16 PM, Clément Bera <[hidden email]> wrote:
>> I don't think we do. Do you need it on SequenceableCollection or
>> HashedCollection too ?
>>
>> Recently I was trying to iterate over the first N elements of a collection
>> and since there was no #first:do: I used #from:to:do:. I guess you could use
>> that too:
>>
>> aCollection from: 1 to: (aCollection size min: 1000) do: aBlock
>>
>> Which guarantees you iterate at max over 1000 elements. But that API is
>> SequenceableCollection specific.
>>
>> On Sun, Jan 21, 2018 at 11:44 AM, Ben Coman <[hidden email]> wrote:
>>>
>>> On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]>
>>> wrote:
>>> > Hi
>>> >
>>> > I would like to iterate at max on a certain amount of elements in a
>>> > collection.
>>> > And I was wondering if we have such iterator.
>>>
>>> I'm not clear what functionality your asking for. Could you present
>>> it as code & result if you assumed the iterator you want was
>>> available?
>>>
>>> cheers -ben
>>>
>>
>>
>>
>> --
>> Clément Béra
>> Pharo consortium engineer
>> https://clementbera.wordpress.com/
>> Bâtiment B 40, avenue Halley 59650 Villeneuve d'Ascq
>

jgfoster

Re: looking for another iterator :)

In reply to this post by Stephane Ducasse-3

Since ‘atMax:’ doesn’t seem as clear to me, I’d prefer ‘upToMax:’ or ‘withMax:’ or (especially) the following:

upTo: anInteger timesDo: aBlock
upTo: anInteger timesSelect: aBlock
upTo: anInteger timesCollect: aBlock

James Foster

> On Jan 21, 2018, at 8:56 AM, Stephane Ducasse <[hidden email]> wrote:
>
> I thought about something like that...
>
> SequenceableCollection >> atMax: numberOfItems do: aBlock
> "Execute the iteration with at the maximum numberOfItems. If the
> receiver contains less than numberOfItems iterate them all."
> 1 to: (numberOfItems min: self size) do: [:index | aBlock value:
> (self at: index)]
>
> This is an abstraction that we need to treat some samples.
>
> Stef
>
> On Sun, Jan 21, 2018 at 5:47 PM, Stephane Ducasse
> <[hidden email]> wrote:
>> Hi Ben and Clement
>>
>> I have a collection (a dictionary in my case) and I want to get
>> maximum 5 bindings out of it and iterate on them.
>> I want keysAndValuesDo: or do: but only up to 5 elements.
>>
>> aDict atMax: 5 do: [:each | ]
>>
>> So I learned from:to:do:
>>
>> aCollection atMax: 5 do: [:each | ]
>>
>> Does it make sense?
>>
>> Stef
>>
>> On Sun, Jan 21, 2018 at 1:16 PM, Clément Bera <[hidden email]> wrote:
>>> I don't think we do. Do you need it on SequenceableCollection or
>>> HashedCollection too ?
>>>
>>> Recently I was trying to iterate over the first N elements of a collection
>>> and since there was no #first:do: I used #from:to:do:. I guess you could use
>>> that too:
>>>
>>> aCollection from: 1 to: (aCollection size min: 1000) do: aBlock
>>>
>>> Which guarantees you iterate at max over 1000 elements. But that API is
>>> SequenceableCollection specific.
>>>
>>> On Sun, Jan 21, 2018 at 11:44 AM, Ben Coman <[hidden email]> wrote:
>>>>
>>>> On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]>
>>>> wrote:
>>>>> Hi
>>>>>
>>>>> I would like to iterate at max on a certain amount of elements in a
>>>>> collection.
>>>>> And I was wondering if we have such iterator.
>>>>
>>>> I'm not clear what functionality your asking for. Could you present
>>>> it as code & result if you assumed the iterator you want was
>>>> available?
>>>>
>>>> cheers -ben
>>>>
>>>
>>>
>>>
>>> --
>>> Clément Béra
>>> Pharo consortium engineer
>>> https://clementbera.wordpress.com/
>>> Bâtiment B 40, avenue Halley 59650 Villeneuve d'Ascq
>
>

Richard Sargent

Re: looking for another iterator :)

Administrator

SomeCollection every: 5 do: [:subset | subset collect: [:each | ...]]

etc.

If you want the first five only, return from the do: block.

Possibly, #every: by itself answers an iterator / collection conforming instance.

On Jan 21, 2018 14:47, "James Foster" <[hidden email]> wrote:

Since ‘atMax:’ doesn’t seem as clear to me, I’d prefer ‘upToMax:’ or ‘withMax:’ or (especially) the following:

upTo: anInteger timesDo: aBlock
upTo: anInteger timesSelect: aBlock
upTo: anInteger timesCollect: aBlock

James Foster

> On Jan 21, 2018, at 8:56 AM, Stephane Ducasse <[hidden email]> wrote:
>
> I thought about something like that...
>
> SequenceableCollection >> atMax: numberOfItems do: aBlock
> "Execute the iteration with at the maximum numberOfItems. If the
> receiver contains less than numberOfItems iterate them all."
> 1 to: (numberOfItems min: self size) do: [:index | aBlock value:
> (self at: index)]
>
> This is an abstraction that we need to treat some samples.
>
> Stef
>
> On Sun, Jan 21, 2018 at 5:47 PM, Stephane Ducasse
> <[hidden email]> wrote:
>> Hi Ben and Clement
>>
>> I have a collection (a dictionary in my case) and I want to get
>> maximum 5 bindings out of it and iterate on them.
>> I want keysAndValuesDo: or do: but only up to 5 elements.
>>
>> aDict atMax: 5 do: [:each | ]
>>
>> So I learned from:to:do:
>>
>> aCollection atMax: 5 do: [:each | ]
>>
>> Does it make sense?
>>
>> Stef
>>
>> On Sun, Jan 21, 2018 at 1:16 PM, Clément Bera <[hidden email]> wrote:
>>> I don't think we do. Do you need it on SequenceableCollection or
>>> HashedCollection too ?
>>>
>>> Recently I was trying to iterate over the first N elements of a collection
>>> and since there was no #first:do: I used #from:to:do:. I guess you could use
>>> that too:
>>>
>>> aCollection from: 1 to: (aCollection size min: 1000) do: aBlock
>>>
>>> Which guarantees you iterate at max over 1000 elements. But that API is
>>> SequenceableCollection specific.
>>>
>>> On Sun, Jan 21, 2018 at 11:44 AM, Ben Coman <[hidden email]> wrote:
>>>>
>>>> On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]>
>>>> wrote:
>>>>> Hi
>>>>>
>>>>> I would like to iterate at max on a certain amount of elements in a
>>>>> collection.
>>>>> And I was wondering if we have such iterator.
>>>>
>>>> I'm not clear what functionality your asking for. Could you present
>>>> it as code & result if you assumed the iterator you want was
>>>> available?
>>>>
>>>> cheers -ben
>>>>
>>>
>>>
>>>
>>> --
>>> Clément Béra
>>> Pharo consortium engineer
>>> https://clementbera.wordpress.com/
>>> Bâtiment B 40, avenue Halley 59650 Villeneuve d'Ascq
>
>

Ben Coman

Re: looking for another iterator :)

In reply to this post by Stephane Ducasse-3

On 22 January 2018 at 00:47, Stephane Ducasse <[hidden email]> wrote:
> Hi Ben and Clement
>
> I have a collection (a dictionary in my case) and I want to get
> maximum 5 bindings out of it and iterate on them.
> I want keysAndValuesDo: or do: but only up to 5 elements.
>
> aDict atMax: 5 do: [:each | ]

"atMax" sound a bit like comparison rather than counting. Perhaps
better would be...
aDict atMost: 5 do: [:each | ] "or"
aDict for: 5 do: [:each | ]

but rather than introduce three or more messages...
aDict atMost: 5 do: [:each| ... ]
aDict atMost: 5 select: [:each| ... ]
aDict atMost: 5 collect: [:each| ... ]

why not introduce just one method?....
(aDict any: 5) do: [:each| ... ]
(aDict any: 5) select: [:each| ... ]
(aDict any: 5) collect: [:each| ... ]

cheers -ben

> So I learned from:to:do:
>
> aCollection atMax: 5 do: [:each | ]
>
> Does it make sense?
>
> Stef
>
> On Sun, Jan 21, 2018 at 1:16 PM, Clément Bera <[hidden email]> wrote:
>> I don't think we do. Do you need it on SequenceableCollection or
>> HashedCollection too ?
>>
>> Recently I was trying to iterate over the first N elements of a collection
>> and since there was no #first:do: I used #from:to:do:. I guess you could use
>> that too:
>>
>> aCollection from: 1 to: (aCollection size min: 1000) do: aBlock
>>
>> Which guarantees you iterate at max over 1000 elements. But that API is
>> SequenceableCollection specific.
>>
>> On Sun, Jan 21, 2018 at 11:44 AM, Ben Coman <[hidden email]> wrote:
>>>
>>> On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]>
>>> wrote:
>>> > Hi
>>> >
>>> > I would like to iterate at max on a certain amount of elements in a
>>> > collection.
>>> > And I was wondering if we have such iterator.
>>>
>>> I'm not clear what functionality your asking for. Could you present
>>> it as code & result if you assumed the iterator you want was
>>> available?
>>>
>>> cheers -ben
>>>
>>
>>
>>
>> --
>> Clément Béra
>> Pharo consortium engineer
>> https://clementbera.wordpress.com/
>> Bâtiment B 40, avenue Halley 59650 Villeneuve d'Ascq
>

Guillermo Polito

Re: looking for another iterator :)

In most collection libraries I know there is the "take" function coming from the functional world that does that:

#(1 2 3 4 5 6 7 8) take: 5

=> #(1 2 3 4 5)

#(1 2 3 4) take: 5

=> #(1 2 3 4)

Now, I understand there are two different things in here.

- First is the fact that we would like to apply this iterator to more than sequenceable collections. I think that the name "take" is order agnostic in that sense.

- The other thing is that people would like to not calculate the sub-collection... The problem is that we will end up with ugly combinations of selectors like

take:thenDo:

take:thenCollect:

take:thenSelect:

...

And that pattern already exists also for:

select:thenCollect:

select:thenDo:

collect:as:

select:as:

...

I think I would like to have a more composable kind of iterators/collections. There are Transducers that make "iterators" kind of command objects that you can apply on a collection. Personally I don't like the API choice but the idea behind is nice:

https://github.com/Pharophile/Transducers

sum := #+ init: 0.
sum1 := #(1 1 1) reduce: sum.
sum2 := (1 to: 1000) transduce: #odd filter reduce: sum.

And there are XTreams that allows one to work on a collection as a stream and then compose decorators on top. This means however that we need to create a stream and "close" it to obtain the resulting collection on every manipulation.

https://github.com/mkobetic/Xtreams

https://code.google.com/archive/p/xtreams/wikis/Core.wiki

((aCollection reading collect: [ ... ]) select: [ ... ]) rest.

Guille

On Mon, Jan 22, 2018 at 4:11 AM, Ben Coman <[hidden email]> wrote:

On 22 January 2018 at 00:47, Stephane Ducasse <[hidden email]> wrote:
> Hi Ben and Clement
>
> I have a collection (a dictionary in my case) and I want to get
> maximum 5 bindings out of it and iterate on them.
> I want keysAndValuesDo: or do: but only up to 5 elements.
>
> aDict atMax: 5 do: [:each | ]

"atMax" sound a bit like comparison rather than counting. Perhaps
better would be...
aDict atMost: 5 do: [:each | ] "or"
aDict for: 5 do: [:each | ]

but rather than introduce three or more messages...
aDict atMost: 5 do: [:each| ... ]
aDict atMost: 5 select: [:each| ... ]
aDict atMost: 5 collect: [:each| ... ]

why not introduce just one method?....
(aDict any: 5) do: [:each| ... ]
(aDict any: 5) select: [:each| ... ]
(aDict any: 5) collect: [:each| ... ]

cheers -ben

> So I learned from:to:do:
>
> aCollection atMax: 5 do: [:each | ]
>
> Does it make sense?
>
> Stef
>
> On Sun, Jan 21, 2018 at 1:16 PM, Clément Bera <[hidden email]> wrote:
>> I don't think we do. Do you need it on SequenceableCollection or
>> HashedCollection too ?
>>
>> Recently I was trying to iterate over the first N elements of a collection
>> and since there was no #first:do: I used #from:to:do:. I guess you could use
>> that too:
>>
>> aCollection from: 1 to: (aCollection size min: 1000) do: aBlock
>>
>> Which guarantees you iterate at max over 1000 elements. But that API is
>> SequenceableCollection specific.
>>
>> On Sun, Jan 21, 2018 at 11:44 AM, Ben Coman <[hidden email]> wrote:
>>>
>>> On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]>
>>> wrote:
>>> > Hi
>>> >
>>> > I would like to iterate at max on a certain amount of elements in a
>>> > collection.
>>> > And I was wondering if we have such iterator.
>>>
>>> I'm not clear what functionality your asking for. Could you present
>>> it as code & result if you assumed the iterator you want was
>>> available?
>>>
>>> cheers -ben
>>>
>>
>>
>>
>> --
>> Clément Béra
>> Pharo consortium engineer
>> https://clementbera.wordpress.com/
>> Bâtiment B 40, avenue Halley 59650 Villeneuve d'Ascq
>

Guille Polito

Research Engineer

Centre de Recherche en Informatique, Signal et Automatique de Lille

CRIStAL - UMR 9189

French National Center for Scientific Research - http://www.cnrs.fr

Web: http://guillep.github.io

Phone: +33 06 52 70 66 13

Sven Van Caekenberghe-2

Re: looking for another iterator :)

yes, we need composition to avoid API explosion (things are already very bad in this respect)

> On 22 Jan 2018, at 10:38, Guillermo Polito <[hidden email]> wrote:
>
> In most collection libraries I know there is the "take" function coming from the functional world that does that:
>
> #(1 2 3 4 5 6 7 8) take: 5
> => #(1 2 3 4 5)
>
> #(1 2 3 4) take: 5
> => #(1 2 3 4)
>
> Now, I understand there are two different things in here.
> - First is the fact that we would like to apply this iterator to more than sequenceable collections. I think that the name "take" is order agnostic in that sense.
> - The other thing is that people would like to not calculate the sub-collection... The problem is that we will end up with ugly combinations of selectors like
>
> take:thenDo:
> take:thenCollect:
> take:thenSelect:
> ...
>
> And that pattern already exists also for:
>
> select:thenCollect:
> select:thenDo:
>
> collect:as:
> select:as:
>
> ...
>
> I think I would like to have a more composable kind of iterators/collections. There are Transducers that make "iterators" kind of command objects that you can apply on a collection. Personally I don't like the API choice but the idea behind is nice:
>
> https://github.com/Pharophile/Transducers
>
> sum := #+ init: 0.
> sum1 := #(1 1 1) reduce: sum.
> sum2 := (1 to: 1000) transduce: #odd filter reduce: sum.
>
>
> And there are XTreams that allows one to work on a collection as a stream and then compose decorators on top. This means however that we need to create a stream and "close" it to obtain the resulting collection on every manipulation.
>
> https://github.com/mkobetic/Xtreams
> https://code.google.com/archive/p/xtreams/wikis/Core.wiki
>
> ((aCollection reading collect: [ ... ]) select: [ ... ]) rest.
>
> Guille
>
> On Mon, Jan 22, 2018 at 4:11 AM, Ben Coman <[hidden email]> wrote:
> On 22 January 2018 at 00:47, Stephane Ducasse <[hidden email]> wrote:
> > Hi Ben and Clement
> >
> > I have a collection (a dictionary in my case) and I want to get
> > maximum 5 bindings out of it and iterate on them.
> > I want keysAndValuesDo: or do: but only up to 5 elements.
> >
> > aDict atMax: 5 do: [:each | ]
>
> "atMax" sound a bit like comparison rather than counting. Perhaps
> better would be...
> aDict atMost: 5 do: [:each | ] "or"
> aDict for: 5 do: [:each | ]
>
> but rather than introduce three or more messages...
> aDict atMost: 5 do: [:each| ... ]
> aDict atMost: 5 select: [:each| ... ]
> aDict atMost: 5 collect: [:each| ... ]
>
> why not introduce just one method?....
> (aDict any: 5) do: [:each| ... ]
> (aDict any: 5) select: [:each| ... ]
> (aDict any: 5) collect: [:each| ... ]
>
>
> cheers -ben
>
>
> > So I learned from:to:do:
> >
> > aCollection atMax: 5 do: [:each | ]
> >
> > Does it make sense?
> >
> > Stef
> >
> > On Sun, Jan 21, 2018 at 1:16 PM, Clément Bera <[hidden email]> wrote:
> >> I don't think we do. Do you need it on SequenceableCollection or
> >> HashedCollection too ?
> >>
> >> Recently I was trying to iterate over the first N elements of a collection
> >> and since there was no #first:do: I used #from:to:do:. I guess you could use
> >> that too:
> >>
> >> aCollection from: 1 to: (aCollection size min: 1000) do: aBlock
> >>
> >> Which guarantees you iterate at max over 1000 elements. But that API is
> >> SequenceableCollection specific.
> >>
> >> On Sun, Jan 21, 2018 at 11:44 AM, Ben Coman <[hidden email]> wrote:
> >>>
> >>> On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]>
> >>> wrote:
> >>> > Hi
> >>> >
> >>> > I would like to iterate at max on a certain amount of elements in a
> >>> > collection.
> >>> > And I was wondering if we have such iterator.
> >>>
> >>> I'm not clear what functionality your asking for. Could you present
> >>> it as code & result if you assumed the iterator you want was
> >>> available?
> >>>
> >>> cheers -ben
> >>>
> >>
> >>
> >>
> >> --
> >> Clément Béra
> >> Pharo consortium engineer
> >> https://clementbera.wordpress.com/
> >> Bâtiment B 40, avenue Halley 59650 Villeneuve d'Ascq
> >
>
>
>
>
> --
>
> Guille Polito
> Research Engineer
>
> Centre de Recherche en Informatique, Signal et Automatique de Lille
> CRIStAL - UMR 9189
> French National Center for Scientific Research - http://www.cnrs.fr
>
> Web: http://guillep.github.io
> Phone: +33 06 52 70 66 13

Steffen Märcker

Re: looking for another iterator :)

Hi!

this is straightforward with Transducers, e.g.,

> (Take n: 5) <~ #(1 2 3 4 5 6 7 8).
or
> #(1 2 3 4 5 6 7 8) transduce take: 5.

The different primitives like take, drop, map, filter, etc. are composable
and do not generate intermediate representations.
The bad news are, that the Pharo port is incomplete and I won't have the
time until April to finish it.

Best, Steffen

Am .01.2018, 10:57 Uhr, schrieb Sven Van Caekenberghe <[hidden email]>:

> 5

Esteban A. Maringolo

Re: looking for another iterator :)

In reply to this post by Sven Van Caekenberghe-2

2018-01-22 6:57 GMT-03:00 Sven Van Caekenberghe <[hidden email]>:
> yes, we need composition to avoid API explosion (things are already very bad in this respect)

And the names of the proposed selectors suggests it could be even worst.

+1 to composition.

Esteban A. Maringolo

Stephane Ducasse-3

Re: looking for another iterator :)

In reply to this post by Steffen Märcker

On Mon, Jan 22, 2018 at 11:26 AM, Steffen Märcker <[hidden email]> wrote:

> Hi!
>
> this is straightforward with Transducers, e.g.,
>
>> (Take n: 5) <~ #(1 2 3 4 5 6 7 8).
>
> or
>>
>> #(1 2 3 4 5 6 7 8) transduce take: 5.
>
>
> The different primitives like take, drop, map, filter, etc. are composable
> and do not generate intermediate representations.
> The bad news are, that the Pharo port is incomplete and I won't have the
> time until April to finish it.

oh there is not stress.
What I would like to see is
- what is the API in terms of vocabulary (ie drop the same as reject)
- can we reexpress some of our iterators? what is the cost?

Stef

Stephane Ducasse-3

Re: looking for another iterator :)

In reply to this post by Sven Van Caekenberghe-2

I like the pharophile :)

On Mon, Jan 22, 2018 at 10:57 AM, Sven Van Caekenberghe <[hidden email]> wrote:

> yes, we need composition to avoid API explosion (things are already very bad in this respect)
>
>> On 22 Jan 2018, at 10:38, Guillermo Polito <[hidden email]> wrote:
>>
>> In most collection libraries I know there is the "take" function coming from the functional world that does that:
>>
>> #(1 2 3 4 5 6 7 8) take: 5
>> => #(1 2 3 4 5)
>>
>> #(1 2 3 4) take: 5
>> => #(1 2 3 4)
>>
>> Now, I understand there are two different things in here.
>> - First is the fact that we would like to apply this iterator to more than sequenceable collections. I think that the name "take" is order agnostic in that sense.
>> - The other thing is that people would like to not calculate the sub-collection... The problem is that we will end up with ugly combinations of selectors like
>>
>> take:thenDo:
>> take:thenCollect:
>> take:thenSelect:
>> ...
>>
>> And that pattern already exists also for:
>>
>> select:thenCollect:
>> select:thenDo:
>>
>> collect:as:
>> select:as:
>>
>> ...
>>
>> I think I would like to have a more composable kind of iterators/collections. There are Transducers that make "iterators" kind of command objects that you can apply on a collection. Personally I don't like the API choice but the idea behind is nice:
>>
>> https://github.com/Pharophile/Transducers
>>
>> sum := #+ init: 0.
>> sum1 := #(1 1 1) reduce: sum.
>> sum2 := (1 to: 1000) transduce: #odd filter reduce: sum.
>>
>>
>> And there are XTreams that allows one to work on a collection as a stream and then compose decorators on top. This means however that we need to create a stream and "close" it to obtain the resulting collection on every manipulation.
>>
>> https://github.com/mkobetic/Xtreams
>> https://code.google.com/archive/p/xtreams/wikis/Core.wiki
>>
>> ((aCollection reading collect: [ ... ]) select: [ ... ]) rest.
>>
>> Guille
>>
>> On Mon, Jan 22, 2018 at 4:11 AM, Ben Coman <[hidden email]> wrote:
>> On 22 January 2018 at 00:47, Stephane Ducasse <[hidden email]> wrote:
>> > Hi Ben and Clement
>> >
>> > I have a collection (a dictionary in my case) and I want to get
>> > maximum 5 bindings out of it and iterate on them.
>> > I want keysAndValuesDo: or do: but only up to 5 elements.
>> >
>> > aDict atMax: 5 do: [:each | ]
>>
>> "atMax" sound a bit like comparison rather than counting. Perhaps
>> better would be...
>> aDict atMost: 5 do: [:each | ] "or"
>> aDict for: 5 do: [:each | ]
>>
>> but rather than introduce three or more messages...
>> aDict atMost: 5 do: [:each| ... ]
>> aDict atMost: 5 select: [:each| ... ]
>> aDict atMost: 5 collect: [:each| ... ]
>>
>> why not introduce just one method?....
>> (aDict any: 5) do: [:each| ... ]
>> (aDict any: 5) select: [:each| ... ]
>> (aDict any: 5) collect: [:each| ... ]
>>
>>
>> cheers -ben
>>
>>
>> > So I learned from:to:do:
>> >
>> > aCollection atMax: 5 do: [:each | ]
>> >
>> > Does it make sense?
>> >
>> > Stef
>> >
>> > On Sun, Jan 21, 2018 at 1:16 PM, Clément Bera <[hidden email]> wrote:
>> >> I don't think we do. Do you need it on SequenceableCollection or
>> >> HashedCollection too ?
>> >>
>> >> Recently I was trying to iterate over the first N elements of a collection
>> >> and since there was no #first:do: I used #from:to:do:. I guess you could use
>> >> that too:
>> >>
>> >> aCollection from: 1 to: (aCollection size min: 1000) do: aBlock
>> >>
>> >> Which guarantees you iterate at max over 1000 elements. But that API is
>> >> SequenceableCollection specific.
>> >>
>> >> On Sun, Jan 21, 2018 at 11:44 AM, Ben Coman <[hidden email]> wrote:
>> >>>
>> >>> On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]>
>> >>> wrote:
>> >>> > Hi
>> >>> >
>> >>> > I would like to iterate at max on a certain amount of elements in a
>> >>> > collection.
>> >>> > And I was wondering if we have such iterator.
>> >>>
>> >>> I'm not clear what functionality your asking for. Could you present
>> >>> it as code & result if you assumed the iterator you want was
>> >>> available?
>> >>>
>> >>> cheers -ben
>> >>>
>> >>
>> >>
>> >>
>> >> --
>> >> Clément Béra
>> >> Pharo consortium engineer
>> >> https://clementbera.wordpress.com/
>> >> Bâtiment B 40, avenue Halley 59650 Villeneuve d'Ascq
>> >
>>
>>
>>
>>
>> --
>>
>> Guille Polito
>> Research Engineer
>>
>> Centre de Recherche en Informatique, Signal et Automatique de Lille
>> CRIStAL - UMR 9189
>> French National Center for Scientific Research - http://www.cnrs.fr
>>
>> Web: http://guillep.github.io
>> Phone: +33 06 52 70 66 13
>
>

Richard O'Keefe

Re: looking for another iterator :)

In reply to this post by Stephane Ducasse-3

My own Smalltalk has these:

Enumerable
methods for: 'enumerating'
    limit: n do: aBlock
      "Pass elements of the receiver to aBlock one at a time,
       as for #do:, but stop after n elements. n must be a
       non-negative SmallInteger. Which elements you get is
       for the receiver to decide."
      |count|
      n < 1 ifTrue: [
        n = 0 ifTrue: [^self]ifFalse: [self pvtCountError: n]].
      count := 0.
      self do: [:each |
        aBlock value: each.
        (count := count + 1) < n ifFalse: [^self]].
AbstractKeyedCollection
methods for: 'enumerating'
    limit: n keysAndValuesDo: aBlock
      "Pass keys and corresponding values of the receiver
       to aBlock one at a time, as for #keysAndValuesDo:,
       but stop after n elements. See #limit:do:."
      |count|
      n < 1 ifTrue: [
        n = 0 ifTrue: [^self]ifFalse: [self pvtCountError: n]].
      count := 0.
      self keysAndValuesDo: [:key :value |
        aBlock value: key value: value.
        (count := count + 1) < n ifFalse: [^self]].

Enumerable is the superclass of Collection; it doesn't cover streams but does

cover 2- and 3-dimensional arrays. AbstractKeyedCollection covers both

dictionaries and sequences. Since they only depend on #do: and #keysAndValuesDo:

respectively, they should fit nicely into some sort of Trait(s).

I gave a great deal of thought to the names, and decided on "limit" since it

is already in use in a similar sense in things like LimitedOutputStream or

#printStringLimitedTo:. I did consider #do:limitedTo: and #keysAndValuesDo:limitedTo:

which would be more consistent with #streamContents:limitedTo:, but "heavy" things

like blocks really work better at the end.

Richard O'Keefe

Re: looking for another iterator :)

In reply to this post by jgfoster

I thought about that for my own Smalltalk, but then realised

that I didn't know whether #upTo:timesSelect: was bounding

the number of elements *considered* or the number of elements

in the *result*, and I could argue either way. Arguably the cleanest

way would be to have something like

(LimitedEnumerableAdapter on: collection limit: anInteger)

do: aBlock

select: aBlock

collect: aBlock

... *any* existing or new collection method.

On 22 January 2018 at 11:46, James Foster <[hidden email]> wrote:

Since ‘atMax:’ doesn’t seem as clear to me, I’d prefer ‘upToMax:’ or ‘withMax:’ or (especially) the following:

upTo: anInteger timesDo: aBlock
upTo: anInteger timesSelect: aBlock
upTo: anInteger timesCollect: aBlock

James Foster

> On Jan 21, 2018, at 8:56 AM, Stephane Ducasse <[hidden email]> wrote:
>
> I thought about something like that...
>
> SequenceableCollection >> atMax: numberOfItems do: aBlock
> "Execute the iteration with at the maximum numberOfItems. If the
> receiver contains less than numberOfItems iterate them all."
> 1 to: (numberOfItems min: self size) do: [:index | aBlock value:
> (self at: index)]
>
> This is an abstraction that we need to treat some samples.
>
> Stef
>
> On Sun, Jan 21, 2018 at 5:47 PM, Stephane Ducasse
> <[hidden email]> wrote:
>> Hi Ben and Clement
>>
>> I have a collection (a dictionary in my case) and I want to get
>> maximum 5 bindings out of it and iterate on them.
>> I want keysAndValuesDo: or do: but only up to 5 elements.
>>
>> aDict atMax: 5 do: [:each | ]
>>
>> So I learned from:to:do:
>>
>> aCollection atMax: 5 do: [:each | ]
>>
>> Does it make sense?
>>
>> Stef
>>
>> On Sun, Jan 21, 2018 at 1:16 PM, Clément Bera <[hidden email]> wrote:
>>> I don't think we do. Do you need it on SequenceableCollection or
>>> HashedCollection too ?
>>>
>>> Recently I was trying to iterate over the first N elements of a collection
>>> and since there was no #first:do: I used #from:to:do:. I guess you could use
>>> that too:
>>>
>>> aCollection from: 1 to: (aCollection size min: 1000) do: aBlock
>>>
>>> Which guarantees you iterate at max over 1000 elements. But that API is
>>> SequenceableCollection specific.
>>>
>>> On Sun, Jan 21, 2018 at 11:44 AM, Ben Coman <[hidden email]> wrote:
>>>>
>>>> On 21 January 2018 at 18:36, Stephane Ducasse <[hidden email]>
>>>> wrote:
>>>>> Hi
>>>>>
>>>>> I would like to iterate at max on a certain amount of elements in a
>>>>> collection.
>>>>> And I was wondering if we have such iterator.
>>>>
>>>> I'm not clear what functionality your asking for. Could you present
>>>> it as code & result if you assumed the iterator you want was
>>>> available?
>>>>
>>>> cheers -ben
>>>>
>>>
>>>
>>>
>>> --
>>> Clément Béra
>>> Pharo consortium engineer
>>> https://clementbera.wordpress.com/
>>> Bâtiment B 40, avenue Halley 59650 Villeneuve d'Ascq
>
>

Evan Donahue

Re: looking for another iterator :)

In reply to this post by Guillermo Polito

It is also worth mentioning that there is now also the Cons library available
through the Pharo6 catalog browser. Cons is a lazy linked list that can be
used like a normal linked list, but can also be used as an iterator over
streams or infinite-sequence-generating blocks, using the usual Pharo
collections API.

myStream := (1 to: 100) readStream.
(myStream asCons take: 5) do: [ ... ].

Due to the laziness, Cons, like Clojure's transducers, doesn't build
intermediate representations, so things like #selectThenCollect: aren't
necessary.

(myList select: sBlock) collect: cBlock

just creates an iterator and never actually creates the whole list,
although you can still treat it like a list with #first, #allButRest, etc.

The code is stable and in use in several of my projects.

Evan

--
Sent from: http://forum.world.st/Pharo-Smalltalk-Users-f1310670.html

Steffen Märcker

Re: looking for another iterator :)

In reply to this post by Stephane Ducasse-3

Hi!

No stress is good news!

> - what is the API in terms of vocabulary (ie drop the same as reject)

These are the operations implemented so far. |= means "satisfies", i.e.,
evaluate to true.

Drop drop first n elements
DropWhile drop first elements |= a block
Filter* pick only elements |= a block
Keep* only use elements ~= nil
Map* map each element
MapKeys* map each element an use as key
Partition split after n elements
PartitionBy split after elements |= a block
RandomSample* pick elements with probability p
Reductions intermediate results of reduce
Remove* = Filter not
Replace* replace elements by LUT
Cat* concatenate sequences
Dedupe remove consecutive duplicates
Flatten* flatten nested sequence
Take pick first n elements
TakeNth pick every n-th element
TakeWhile pick first elements |= a block
Tee UNIX tee, concurrent evaluation

Note, * means that the operation is parallelizable. As the operations are
independent of the sequence class, the apply naturally to all kinds of
sources, like collections, streams, channels and so on.

> - can we reexpress some of our iterators?

Most of them. For example, generic for all collections:

collect: aBlock
^self class <~ aBlock map <~ self
reject: aBlock
^self class <~ ablock remove <~ self
select: aBlock
^self class <~ aBlock filter <~ self

As said before, names are not fixed yet and there is a more classical API
on top available, too:

collect: aBlock
^(self transduce map: aBlock) into: self class

> - what is the cost?

Very little. In detail:
1) Upfront there is the constant cost of instantiating the tranducers.
2) The linear cost of evaluating a nested block for each element. This is
likely to be optimized by the JIT, as the structure is very regular.

I only did some micro-benchmarks which showed little to none impact on
performance so far.

Best,
Steffen