Introducing both syntaxes indeed is a bit confusing. I don”Ēt think

[1, 10, 100].map &.to_s.length

is much better than

[1, 10, 100].map { |i| i.to_s.length }

I think the latter is clearer. I'm fond of having some sugar for positional parameter access (like % in clojure or & in elixir), though.  

--  
Fuad Saud
Sent with Sparrow (http://www.sparrowmailapp.com/?sig)


On Monday, November 4, 2013 at 1:57 PM, shevegen (markus heiler) wrote:

>  
> Issue #9076 has been updated by shevegen (markus heiler).
>  
>  
> Note that if &: would be removed at the same time and &. added I would not mind it that much. You could use & as a reference to a global object,just similar to how $1 or $2 is automagically set for regexes. But to keep two different syntaxes for semi-similar issues is very bad.
> ----------------------------------------
> Feature #9076: New one-argument block syntax: &.
> https://bugs.ruby-lang.org/issues/9076#change-42742
>  
> Author: asterite (Ary Borenszweig)
> Status: Open
> Priority: Normal
> Assignee:  
> Category: core
> Target version: current: 2.1.0
>  
>  
> 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, whichhas a syntax very similar to Ruby, and so far we think it's nice, simpleand powerful. You can read more about it here: http://crystal-lang.org/2013/09/15/to-proc.html
>  
>  
> --  
> http://bugs.ruby-lang.org/
>  
>