Feature #9076

Updated by nobu (Nobuyoshi Nakada) almost 8 years ago


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


 - 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`" "&:to_s" is slower because the `to_proc` 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). 


 - Only supports one (implicit) argument. But this is the same limitation of "`&:to_s`". "&: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` &:to_s syntax, which is hard to explain (this calls the "`to_proc`" "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: