Object loops and what they return

ruby-talk
1

Consider these loops:

<object>.<loop-method> { <code> }

where loop method is each, each_with_index, upto, downto, step,
and probably others.

Although it is not documented, all of these look to return the
origninal object (collection or int). Does anybody find this
useful?? If not, I would propose that these return nil just
like loop, while, until, begin/end while, and begin/end until.
I've never found the return value of these methods useful, but
I have found the the built-in loops returning nil useful. Here
are a couple:

# find first index where you find the object obj in array
index = array.each_with_index do |i,x|
    break(i) if obj.equal?(x)
end

# find last index where you find the object obj in array
index = (array.size-1).downto(0) do |i,x|
    break(i) if obj.equal?(x)
end

The problem with the above now is that index will be the loop
object (array and array.size-1 from above) when you don't find
the obj. Instead of the above, I end up using old-style loops
to accomplish what I want.

With "each" returning nil, you can also see that many of the
derived loops in Enumerable become trival almost to where you
don't need them.

Yahoo! Mail
Stay connected, organized, and protected. Take the tour:
http://tour.mail.yahoo.com/mailtour.html

2

"Eric Mahurin" <eric_mahurin@yahoo.com> schrieb im Newsbeitrag news:20050511195851.99230.qmail@web41121.mail.yahoo.com...

Consider these loops:

<object>.<loop-method> { <code> }

where loop method is each, each_with_index, upto, downto, step,
and probably others.

Although it is not documented, all of these look to return the
origninal object (collection or int). Does anybody find this
useful?? If not, I would propose that these return nil just
like loop, while, until, begin/end while, and begin/end until.
I've never found the return value of these methods useful, but
I have found the the built-in loops returning nil useful. Here
are a couple:

# find first index where you find the object obj in array
index = array.each_with_index do |i,x|
   break(i) if obj.equal?(x)
end

# find last index where you find the object obj in array
index = (array.size-1).downto(0) do |i,x|
   break(i) if obj.equal?(x)
end

a=%w{a b c d e f g ab c}

=> ["a", "b", "c", "d", "e", "f", "g", "ab", "c"]

a.index "c"

=> 2

a.rindex "c"

=> 8

a.index "foo"

=> nil

The problem with the above now is that index will be the loop
object (array and array.size-1 from above) when you don't find
the obj. Instead of the above, I end up using old-style loops
to accomplish what I want.

With "each" returning nil, you can also see that many of the
derived loops in Enumerable become trival almost to where you
don't need them.

Interesting aspect. I assume the return behavior is from a time where break could not return a value so your constructions weren't possible.

Typically I put such functionality into methods and then I use "return" to short circuit:

module Enumerable
  def find_pos(x)
    each_with_index {|e,i| return i if x == e}
    nil
  end

  def find_cond
    each_with_index {|e,i| return i if yield e}
    nil
  end
end

Kind regards

    robert

3

I use it occasionally for doing evil method chaining. Somewhere I
heard it is evil, but sometimes its nice.

So your proposal indeed allows for some nifty operations.

regards,

Brian

···

On 11/05/05, Eric Mahurin <eric_mahurin@yahoo.com> wrote:

Consider these loops:

<object>.<loop-method> { <code> }

where loop method is each, each_with_index, upto, downto, step,
and probably others.

Although it is not documented, all of these look to return the
origninal object (collection or int). Does anybody find this
useful?? [snip]

--
http://ruby.brian-schroeder.de/

Stringed instrument chords: http://chordlist.brian-schroeder.de/

4

Hi --

Consider these loops:

<object>.<loop-method> { <code> }

where loop method is each, each_with_index, upto, downto, step,
and probably others.

Although it is not documented, all of these look to return the
origninal object (collection or int).

I think the return values are documented in ri for all of these.

[...]

With "each" returning nil, you can also see that many of the
derived loops in Enumerable become trival almost to where you
don't need them.

On the other hand, if you were to do this (looking for nil):

   obj = array.each {|e| break(e) if e.nil? }

and each returned nil, you wouldn't know whether you'd succeeded or
not.

The various find and include? and any? and index methods are probably
your best bet for this kind of operation.

David

···

On Thu, 12 May 2005, Eric Mahurin wrote:

--
David A. Black
dblack@wobblini.net