From: "Hanmac (Hans Mackowiak)" Date: 2013-11-04T23:42:36+09:00 Subject: [ruby-core:58150] [ruby-trunk - Feature #9076] New one-argument block syntax: &. Issue #9076 has been updated by Hanmac (Hans Mackowiak). my first idea is this: class Symbol def call(*args) proc {|obj| obj.public_send(self,*args) } end end [1,2,3,4].map &:to_s.(2) # => ["1", "10", "11", "100"] it is not chainable yet but its a nice beginning (and already valid ruby code) ---------------------------------------- Feature #9076: New one-argument block syntax: &. https://bugs.ruby-lang.org/issues/9076#change-42740 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, 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/