Issue #11141 has been updated by Jan Lelis.


Hans Mackowiak wrote:
> my problem i got with that new syntax is what does it do when i have blocks inside of blocks, specially with different arity count ...

I'd say, such a implicit block parameters should only be possible for the most inner block. Somehow accessing the arguments of an outer block probably does not make the code better readable. However, having simple (unnested) blocks with implicit variables *can* improve the readability, because it is more concise. Like, for example, it is already possible with gsub:

~~~
"Ruby".gsub(/(.)(.)/){ $1.downcase + $2.upcase } #=> "rUbY"
~~~

----------------------------------------
Feature #11141:  new syntax suggestion for abbreviate definition on block parameters in order
https://bugs.ruby-lang.org/issues/11141#change-52423

* Author: Arnold Roa
* Status: Rejected
* Priority: Normal
* Assignee: ruby-core
----------------------------------------
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`** that allows calling a method on a block if only one param is expected. It's a shortcut 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` and `$2` just as an example. I don't like the fact that they are global variables. It could be `_1` or `p1`, for example:

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

Or, as blocks already uses **`&:method`** it could be **`&: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` nor `p1`. They are just the first quick things that come to my mind.




-- 
https://bugs.ruby-lang.org/