Issue #4830 has been updated by markus heiler.


The last example:

  some_array.map(&method(:foo)).select(&method(:bar)).each(&method(:bar))

Is no advantage. First, it is longer. Second, using & is ugly.

I think it would be nice to access block arguments by position somehow, without naming them specifically.

The problem with:

  some_array.map { foo(it) }.select { bar(it) }.each { baz(it) }

Is that it is not obvious where "it" comes from.

How about this though:

  some_array.map { |it| foo(it) }.select { bar(it) }.each { baz(it) }

In this example, if a block variable was not found, it first checks
whether another block variable with its name was defined for the 
object the operation is done on. In the above example, bar(it) would
understand that "it" is the first block argument.

I am not sure if this would complicate things.

What I myself sometimes want to do is this:

  array.map { foo(_) }.select { bar(_) }.each { baz(_) }

This looks cleaner to me than:

  array.map { |_| foo(_) }.select { |_| bar(_) }.each { |_| baz(_) }

A compromise could be:

  array.map { |_| foo(_) }.select { bar(_) }.each { baz(_) }

But it's still not all too terribly beautiful either compared to the:

  array.map { foo(_) }.select { bar(_) }.each { baz(_) }

It would be nice if Ruby could support some kind of implicit names
though. There already are some ruby conventions, such as constants
have to start with an UPCASED character. And noone hates such a 
convention.

In principle it could be possible to allow a naming convention that
can be accepted by folks.

PS: some_array.map(&method(:foo)).select(&method(:bar)).each(&method(:bar)) 
is really ugly. It is much uglier than what Ilias suggested too!

  names.each { |name| print name, "\n" }
  names.each { print item, "\n" }

My only gripe with his proposal is that noone really knows where "item" 
came from. The advantage of _ would at least be that noone needs a 
name for it, but also noone quite knows where it came from. :/

How about another crazy proposal though:

  names.each { print argument_1, "\n" }

This is such an unlikely name ... could be made available in every
method too!

  argument_1
  argument_2
  argument_3

PSS: I know that noone likes it. But hey, it can still be used for 
discussion.
----------------------------------------
Feature #4830: Provide Default Variables for Array#each and other iterators
https://bugs.ruby-lang.org/issues/4830

Author: Lazaridis Ilias
Status: Assigned
Priority: Low
Assignee: Yukihiro Matsumoto
Category: core
Target version: 


for arrays: use "item" by default
for hashes: use "key" and "value" by default

names = ["Jane", "Michele", "Isabella"]
names.each { |name| print name, "\n" } 
names.each { print item, "\n" } 

contact = {name:"Jane", phone:"1234567"}
contact.each { |key, value| print key, ": ", value, "\n"}
contact.each { print key, ": ", value, "\n"}

-

The benefits are:

* more compact code (without loosing clarity of the code).
* no repetitions ("names, name, name") in a one-liner with {} block

This extension does not break any existent behaviour.


-- 
http://bugs.ruby-lang.org/