[ruby-core:69144] [Ruby trunk - Feature #11141] new syntax suggestion for abbreviate definition on block parameters in order

Issue #11141 has been updated by Arnold Roa.


Yukihiro Matsumoto wrote:
> We cannot use `$1` etc. as they are already taken for `Regexp` match.
> Short hand notation for block parameter itself is a nice idea though.
> 
> Matz.

Yes, I just use $1 as an example to explain the idea, by no means I think $1 would be a good choice as $ is for global variables and $1..2..3 are reserved for Regexp. The idea I wanted to point here is the short-hand syntax. 

@1 is a good idea, but @ is used for instance variables. So I'm not sure if is the ideal.

On method definition we can use *args for multiple arguments, so what about *1, *2, *3?

~~~
x.method{ *1 - *2 }
~~~


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

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