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/ > >