Issue #9076 has been updated by alexeymuranov (Alexey Muranov).


> Note that in doing `array.map &:to_s` the `do ... end` and curly braces are also missing. However, the `&` signals a block, just as when you do `foo &block`. This is no different than `foo &.something` where, again, the `&` signals a block.

Ary, in `array.map &:to_s` curly braces are missing because there is no literal block definition, the block is the result of the `&` operator applied to a symbol.

The main problem IMO with your proposed syntactic sugar for the common special case is that it adds a completely new syntactic rule to Ruby, and also breaks one or more of existing ones.  Normally in Ruby

<method_name1> <identifier1>.<method_name2>.<method_name3>

means: "call the method named by <method_name2> on the object named by <identifier1> or value returned by the method <identifier1>, then call the method named <method_name3> on the result, then yield the result as the argument to a call of the method named by <method_name1>"

(I am not a specialist, i am not sure i am using all the terms correctly.)

It seems to me that what you are looking for is probably a shorter notation for a one-argument lambda.  I personally doubt that there is much space in Ruby syntax to introduce it.

Skipping the curly braces does not look to me like a benefit and may make the syntax ambiguous or not flexible.

The performance penalty of the `&` operator probably can be worked around by compiling the code.

Avoiding the hassle of naming the bound variable IMHO is not ... worth the hassle. :)  Well, if i rely wanted that myself, i might have proposed something like

  [1, 2, 3, 4].map &->{ -.to_s(2) }

----------------------------------------
Feature #9076: New one-argument block syntax: &.
https://bugs.ruby-lang.org/issues/9076#change-42782

Author: asterite (Ary Borenszweig)
Status: Feedback
Priority: Low
Assignee: 
Category: core
Target version: Next Major


Hello,

I'd like to introduce a new syntax for blocks that have one argument.

Currently you can do this:

[1, 2, 3].map &:to_s

With the proposed syntax this will be written as:

[1, 2, 3].map &.to_s

Instead of ":" we use a ".".

The idea is that this new syntax is just syntax sugar that is expanded by the parser to this:

[1, 2, 3].map { |arg| arg.to_s }

This new syntax allows passing arguments:

[1, 2, 3, 4].map &.to_s(2) #=> ["1", "10", "11", "100"]

It also allows chaining calls:

[1, 10, 100].map &.to_s.length #=> [1, 2, 3]

You can also use another block:

[[1, -2], [-3, -4]].map &.map &.abs #=> [[1, 2], [3, 4]]

Pros:
- Doesn't conflict with any existing syntax, because that now gives a syntax error, so it is available.
- Allows passing arguments and chaining calls
- It's *fast*: it's just syntax sugar. The "&:to_s" is slower because the to_proc method is invoked, you have a cache of procs, etc.
- It looks ok (in my opinion) and allows very nice functional code (like the last example).

Cons:
- Only supports one (implicit) argument. But this is the same limitation of "&:to_s". If you want more than one argument, use the traditional block syntax.
- It's a new syntax, so users need to learn it. But to defend this point, users right now need to understand the &:to_s syntax, which is hard to explain (this calls the "to_proc" method of Symbol, which creates a block... vs. "it's just syntax sugar for")

What do you think?

We are using this syntax in a new language we are doing, Crystal, which has a syntax very similar to Ruby, and so far we think it's nice, simple and powerful. You can read more about it here: http://crystal-lang.org/2013/09/15/to-proc.html


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