Ruby » Ruby master

Feature #11141

Updated by nobu (Nobuyoshi Nakada) over 9 years ago

One of the most commons things I do in Ruby are small block definitions: 

 ~~~ruby ~~~ 
 x.each{|a| a} 
 ~~~ 

 One useful syntax introduced was the **`&:method`** **&:method** that allows calling a method on a block if only one param is expected. It's a shortcut for **`a.each{|x|x.method}`**. shorcut for** a.each{|x|x.method}**. I think it would be nice if Ruby had a syntax that allows me to not define the params that block would receive, but instead access them in order. For example: 

 ~~~ruby ~~~ 
 x.each { $1 } 
 ~~~ 

 Let's suppose the block is waiting for two params, I normally do: 

 ~~~ruby ~~~ 
 x.method {|a,b| a - b } 
 ~~~ 

 This syntax will allow us to use: 

 ~~~ruby ~~~ 
  x.method{ $1 - $2 } 
 ~~~  

 So: 

 ~~~ruby ~~~ 
  x.each { p1.stg } 
  x.each {|p1| p1.stg} 
  x.each &:stg 
 ~~~ 

 would be the same. 

 Please consider `$1` $1 and `$2` $2 just as an example. I don't like the fact that they are global variables. It could be `_1` _1 or `p1`,    p1, for example: 

 ~~~ruby ~~~ 
 x.method{ p1 - p2 }  
 x.each{ p1 - p2 } == x.each {|p1, p2| p1 - p2 } 
 ~~~ 

 Or, as blocks already uses **`&:method`** **&:method** it could be **`&:1`**. ** &:1**. Or any other thing that you may consider more appropriated. 

 I think this syntax would be very nice for short block definitions, the downside is that it allows for bad practice on longer methods, but in the end, that's a decision that a programer should make. 

 Maybe this is not a valid reason, but I would like to point out that Regex is actually creating global vars as the results of match: $x vars. (for perl's historical reasons) 

 So why not introduce this into Ruby's syntax? 

 Personally I don't like either `$1` $1 nor `p1`. p1. They are just the first quick things that come to my mind. 

Back