On Sun, 16 Oct 2011, St�phane Ducasse wrote:

On Oct 16, 2011, at 10:33 PM, Nicolas Cellier wrote:

Ah, I see, this sound appealing.
But I would object this: (I'm speaking of do:, not only to:do:)
1) what the last value mean for unordered collections?
2) for a SequenceableCollection, the behavior is already
(someCollection inject: nil into: [:void :each | aBlock value: each])
3) returning the last value in all implementors of #do: would cost
complexification of code and possibly slow down (non clean blocks)

Is it really useful?

Not really I do not like the idea to rely on it.
but in that case the code you be explicit

� � � �#undefined/nil
� � � �should be the last expression of the block.

My point was: the semantics of a block is to return the last expression and we should be consistent with that.

The block returns the last expression, but in this case a method returns
the value. Here's an example:

(1 to: 10) collect: [ :each | each squared ].

You don't expect to get 100 as the result, do you? :)

Levente

Stef

Nicolas

2011/10/16 St�phane Ducasse <stephane.ducasse@inria.fr>:

for me the last expression of the block.

Stef

Which return value would be useful?

That's not the right question. �IMO the compiler should answer the same
result as the non-inlined one when the return value is asked for. �Arguably
the non-inline version needs to be commented to specify that it returns the
value it does (in this case self), and that the compiler's optimiser
reflects this.

Agree, but I was wondering what useful object this common answer could be?

Nicolas

2011/10/16 St�phane Ducasse <stephane.ducasse@inria.fr>:

A friend of mine ask me the following

|result|
result := String new.
1 to: 10 do: [:n | result := result, n printString, ' '].
I am trying to do or print this code. It prints 'nil' instead of a
collection. Its an example from PBE book.
do you know the reason?
although this one's working:
result := String new.
(1 to: 10) do: [:n | result := result, n printString, ' '].

I checked the implementation
Interval>>do: aBlock
"Evaluate aBlock for each value of the interval.
Implementation note: instead of repeatedly incrementing the value
aValue := aValue + step.
until stop is reached,
We prefer to recompute value from start
aValue := start + (index * step).
This is better for floating points accuracy, while not degrading Integer
and
Fraction speed too much.
Moreover, this is consistent with methods #at: and #size"
| aValue index size |
index := 0.
size := self size.
[index < size]
whileTrue: [aValue := start + (index * step).
index := index + 1.
aBlock value: aValue]

Number>>to: stop do: aBlock
"Normally compiled in-line, and therefore not overridable.
Evaluate aBlock for each element of the interval (self to: stop by: 1)."
| nextValue |
nextValue := self.
[nextValue <= stop]
whileTrue:
[aBlock value: nextValue.
nextValue := nextValue + 1]

any further idea than := value is different from value:
Stef

--
best,
Eliot