Issue #6869 has been updated by alexeymuranov (Alexey Muranov).


marcandre (Marc-Andre Lafortune) wrote:
> Hi,
> 
> alexeymuranov (Alexey Muranov) wrote:
> > I propose to not treat the variable name "(({_}))" exceptionally.
> 
> Sorry for the naive question, but why? What are you trying to achieve? What real world problem do you want to fix?

I do not like exceptions.  When i was first learning Ruby, i thought that the underscore is a letter like any other, but sometimes it behaves like any other, and sometimes not.

It also seems to me more natural to use a placeholder for a discarded value than to assign it to a variable first and than discard/garbage collect.
 
> > 3. For unused variables i propose to introduce a special placeholder
> 
> I feel that unused variables do not warrant a change to the already complex Ruby syntax.

In my opinion, treating variables differently based on their names is also a part of syntax, and in my opinion such rules are harder to follow than a rule for a single placeholder.  As there is no dedicated placeholder in Ruby now, this one may be adapted later to other situations as well, i think.
----------------------------------------
Feature #6869: Do not treat `_` parameter exceptionally
https://bugs.ruby-lang.org/issues/6869#change-28886

Author: alexeymuranov (Alexey Muranov)
Status: Open
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: core
Target version: 3.0


=begin
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:

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

prints "[0, 1]", but

 {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:

 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):

 each_with_index { |-, value| puts value }

 -, -, suffix = parse(name)

=end



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