[ruby-core:92244] [Ruby trunk Misc#15723] Reconsider numbered parameters

[loic.nageleisen@gmail.com]

Issue #15723 has been updated by lloeki (Loic Nageleisen).


I very much like the feature itself, esp. for one liners you can come up with on a pry prompt. What I very much dislike though is the use of `@` which is a glorious hack if there is any since currently `@` tokenizably resolves to 'instance variable' in many a brain. In fact I'd very much be happy to use `%1` as a syntax since that would match the `%1` placeholders in strings right away: `%` easily translates to "positional". `"%1"` in strings, `\1` in regex for backrefs, `$1` for regex groups... Yes, `{ %1 }` in blocks somehow works as a metapattern, but reusing `@1` vs `@myvar` is such a mismatch that it brings a terrible cognitive dissonance (just see e.g how in `[1, 2, 3].each { @1 + @l }` both `@` have different scopes!). 

`_` is often used to ignore an argument (like e.g `{}.each { |_, v| ... }`) or to ignore a return value (like `a, _ = "".split(',', 1)`), so using it as JS's `arguments` keyword feels off. Yet simultaneously, a block that has no explicit arguments would obviously not have `_` in its argument list, so this somehow works, but still conflicts with the second case I think. Continuing with the `%` notation, maybe `%_` would be semantically nice, echoing both to the `%` "positional" meaning and the `$_` variable.

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

* Author: sos4nt (Stefan Schüßler)
* 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/