[ruby-core:62009] [ruby-trunk - Feature #6869] Do not treat `_` parameter exceptionally

Issue #6869 has been updated by Alexey Muranov.


Nobuyoshi Nakada wrote:
> Alexey Muranov wrote:
> > Observe also that the use of repeated `_` parameter is not consistent between methods and blocks: for methods the value is the first assigned value, and for blocks it is the array of all the assigned values.
> 
> It is unrelated to `_`, but because of `Enumerable#each_with_index`.
> Try:
> 
>     {0=>1}.each_with_index {|x,y| p x} # [0, 1]

Thanks, i do not know what i was thinking.

> Alexey Muranov wrote:
> > It looks like the use of the underscore `_` as a "placeholder" is quite common in other languages ("black hole" register in Vim, "whatever" pattern that matches everything in Haskell), but there it is really a placeholder and not a variable: values "assigned" to `_` cannot be retrieved.
> 
> Isn't it more exceptional?

Yes, so this proposal would need to be closed, and i would need to open a new one.  When i opened this one, i did not know that the underscore was a common "placeholder" in other languages and i thought that Ruby documentation presents the underscore in identifiers roughly as equivalent to a lowercase letter (doesn't it?).

Here is a sentence from the online version of *Programming Ruby*:
> In these descriptions, lowercase letter means the characters ``a'' though ``z'', as well as ``_'', the underscore.

In any case, in Ruby the following works perfectly, and in my opinion this all is confusing:

    _ = 1
    p _

So, yes, my new proposal would be to downgrade the underscore to a placeholder, so that in something like this

    foo do |_,x|
      # 10 lines of code
    end

it would be immediately clear the only the second argument is used.

----------------------------------------
Feature #6869: Do not treat `_` parameter exceptionally
https://bugs.ruby-lang.org/issues/6869#change-46198

* Author: Alexey Muranov
* Status: Open
* Priority: Normal
* Assignee: Yukihiro Matsumoto
* Category: core
* Target version: Next Major
----------------------------------------
I started by commenting on #6693, but i have realized that  this is a slightly different request.

I propose to not treat the variable name "`_`" exceptionally. Current behavior:

~~~ruby
 {0=>1}.each_with_index { |_,_| p _ } # [0, 1]
~~~

prints "[0, 1]", but

~~~ruby
 {1=>2}.each_with_index { |x,x| p x } # SyntaxError: (eval):2: duplicated argument name
~~~

raises  "SyntaxError: (eval):2: duplicated argument name".

Similarly for methods:

~~~ruby
 def f(_, _)
   _
 end
 f(0, 1) # => 0

 def f(x, x)
   x
 end # => SyntaxError: (eval):2: duplicated argument name
~~~

Observe also that the use of repeated `_` parameter is not consistent between methods and blocks: for methods the value is the first assigned value, and for blocks it is the array of all the assigned values.

1. I propose to use the same rule for all variables, without distinguishing `_` specially.

In particular i propose to allow to repeat any variable, not only `_`, in block or method arguments without raising an error.

There may be several solutions what the repeated argument will hold: it may hold the array of all assigned values, the first assigned value, the last assigned value, the first non-nil assigned value, or the last non-nil assigned value.

2. I propose to treat repeated arguments in methods and in blocks the same way (do not know which one).

3. For unused variables i propose to introduce a special placeholder, for example "`-`" not followed by anything other than a delimiter (comma or bracket):

~~~ruby
 each_with_index { |-, value| puts value }

 -, -, suffix = parse(name)
~~~




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