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

[waheed.barghouthi@gmail.com]

Issue #15723 has been updated by waheedi (Waheed Barghouthi).


jeremyevans0 (Jeremy Evans) wrote:
> As I expressed in the developer meeting today, after a lot of thought, I believe if we want to support implicit block arguments, we should limit support to a single argument, and use `@` to represent the argument.
> 
> As Marc showed, blocks that accept a single argument are much more popular than blocks that accept more than one argument.  For blocks that accept multiple arguments, referencing the arguments by position rather than by name will make the code less understandable, not more.
> 
> Most of the objections with `@` in regards to syntax are because the references look like instance variables, and most Rubyists do not know that `@1` is not a valid instance variable.  Using a bare `@` should avoid or at least mitigate that problem.  I don't know if there is a sigil other than `@` that will work. `\` worked for the case where you are using a position number, but it will not work without that, because then it can be interpreted as a line continuation.  `%` and similar sigils that are binary operators cannot be used because they will be interpreted as a binary operator:
> 
> ```ruby
> proc do
>   foo %
>   bar
> end
> # parsed as proc{foo().%(bar())}
> ```


That's great news. It makes more sense for a single argument. `@` on its own should be enough. But why it can't be like this? `@[0]` I think its more clear, just saying.

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

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