Issue #15723 has been updated by jeremyevans0 (Jeremy Evans).


dvogel (Drew Vogel) wrote:
> matz (Yukihiro Matsumoto) wrote:
> > Yes, I admit `{ @1[@2] = "Go Fish: #{@2}" }` is cryptic. But `{@1 * @2}` is not. So use numbered parameters with care (just like other features in Ruby). The **possibility** to make code cryptic itself should not be the reason to withdraw a feature.
> 
> A small syntactic tweak could avoid overloading `@` while also making it possible for the meaning to be inferred:
> 
> ```
> h = Hash.new { *0[*1] = "Go Fish: #{*1}" }
> ```
> 
> Using the asterisk symbol and switching the indexes to base-0 makes this a shorthand for:
> 
> 
> ```
> h = Hash.new { |*args| args[0][args[1]] = "Go Fish: #{args[1]}" }
> ```
> 
> The asterisk is already overloaded for multiplication and the splat operator. This means everyone already has to consider the context when mentally parsing it. Implied aliases for positional args are at least conceptually near to the splat operator. Much more so than the `@` symbol.

This would not be backwards compatible:

```ruby
class Integer
  def to_a
    [:a]
  end
end

h = {:a=>1, :b=>2}
proc{h[*0]}.call(:b)
# => 1
```

psychoslave (mathieu lovato stumpf guntz) wrote:
> What about introducing a keyword that refer to an array rather than a direct access to each element? For example naming this hypothetical array accessor `by`:
> ``` ruby
> h = Hash.new { by[0][by[1]] = "Go Fish: #{by[1]}" }
> 
> # Or to my mind even more readable :
> h = Hash.new { by.first[by.last] = "Go Fish: #{by.last}" } # Assume that `.last:` returns the second element, something I'm not sure about here, but you get the point anyway, don't you?
> ```

Some issues with this:

* Not backwards compatible as `by` could already be a local variable or method.
* You cannot calculate arity with a syntax that uses a single variable for all arguments.
* Requires 5 characters minimum to access an implicit variable.
* We should avoid adding syntax that requires allocating an array or any other object, as that is bad for performance.
* Any approach that used a single variable that was not a true object would be problematic.  Consider:

```ruby
x = nil
lambda{x = by}.call(0)
x[0]
```

----------------------------------------
Misc #15723: Reconsider numbered parameters
https://bugs.ruby-lang.org/issues/15723#change-77471

* Author: sos4nt (Stefan Schler)
* Status: Feedback
* Priority: Normal
* Assignee: 
----------------------------------------
I just learned that *numbered parameters* have been merged into Ruby 2.7.0dev.

For readers not familiar with this feature: it allows you to reference block arguments solely by their *index*, e.g.

```ruby
[1, 2, 3].each { |i| puts i }

# can become

[1, 2, 3].each { puts @1 }
```

I have an issue with this new feature: I think **it encourages sloppy programming** and results in **hard to read code**.

---

The [original proposal](https://bugs.ruby-lang.org/issues/4475) was to include a special variable (or keyword) with a **readable name**, something like:

```ruby
[1, 2, 3].each { puts it }

# or

[1, 2, 3].each { puts this }
```

Granted, that looks quite lovely and it actually speaks to me  I can *understand* the code. And it fits Ruby: (quoting the website)

> [Ruby] has an elegant syntax that is natural to read and easy to write.

But the proposed `it` / `this` has limited application. It's only useful when dealing with a single argument. You can't have multiple `it`-s or `this`-es. That's why `@1`, `@2`, `@3` etc. were chosen instead.

However, limiting the usefulness to a single argument isn't bad at at. In fact, a single argument seem to be the limit of what makes sense:
```
h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }

# vs

h = Hash.new { @1[@2] = "Go Fish: #{@2}" }
```
Who wants to read the latter? That looks like an archaic bash program (no offense). We already discourage Perl style `$`-references: (from [The Ruby Style Guide](https://github.com/rubocop-hq/ruby-style-guide#no-perl-regexp-last-matchers))

> Don't use the cryptic Perl-legacy variables denoting last regexp group matches (`$1`, `$2`, etc). Use `Regexp.last_match(n)` instead.

I don't see how our code can benefit from adding `@1` and `@2`.

Naming a parameter isn't useless  it gives context. With more than one parameter, naming is crucial. And yes, naming is hard. But avoiding proper naming by using indices is the wrong way.

So please reconsider numbered parameters.

Use a readable named variable (or keyword) to refer to the first argument or ditch the feature entirely.



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

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>