Issue #15723 has been updated by shevegen (Robert A. Heiler).


I think we have quite a bit of repetitive statements going on here. I'll not write too much,
but instead I should like to point out that mame started another thread in regards to the 
single argument situation (such as "it") versus multiple ways to access the block "data".

The two are not the same, by the way, and most of the recent comments are mostly just 
repetition of what has already been discussed before.

Last but not least, I would also like to critisize sikachu's summary at the upcoming
dev meeting here:

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

It's fine to point to another thread, such as this one here, but the "summary" that he
gave is him projecting his own personal opinion, which I consider unfair. People will
have different opinions, everyone understands this, but I have seen this before with
benoit, and I completely disagree with this (see what sikachu wrote in the "summary"
there e. g. "Proposal: Remove @1 and @2 and have only @ for the first argument in
Ruby 2.7+"). In particular such a "style" of "summary" picking gives those ruby users
who have no problem with a feature or change no possibility to comment their own 
opinion. Yes, they can do so here, but why is it also done at the dev meeting as a
"summary"?

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

* Author: sos4nt (Stefan Schler)
* Status: Feedback
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
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.

---Files--------------------------------
implicit-param.diff (20 KB)


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