ruby-core

Issue #9076 has been updated by Nobuyoshi Nakada.

Description updated

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

* Author: 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:

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

With the proposed syntax this will be written as:

~~~ruby
[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:

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

This new syntax allows passing arguments:

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

It also allows chaining calls:

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

You can also use another block:

~~~ruby
[[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




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