Issue #15723 has been updated by Eregon (Benoit Daloze).


@shevegen Please do not write such long comments, and express your opinion more concisely.
This helps everyone to read discussions faster and get the main point.

> This is based on the assumption that there has to be a "fix" at all in the first place

It's just my opinion that this language change is going in the wrong direction.
IMHO @2 and higher are always unclear.

> If @2 @3 @4 is used, then the ruby code that someone writes automatically becomes ...
> perl - yet, if the same ruby user uses e. g. $2 $3 $4, then the ruby code does not
> become perl (in regards to readability)? And .: and & and @@ any other syntax is ... not perl?

Part of it is frequency of usage, $1, $2 is only used for regexps, other sigils are also rarely used compared to letters.
But `@1`, `@2` could be used for potentially many blocks, much more frequently.
The other main point is they replace proper names, which is what hurts readability.
Other sigils do not replace names.
 
> I do not see any problem with code such as this:

I see one, it doesn't work: mixing numbered parameters and named parameters is not allowed.
Also, even if it did a too high number like `@6` could change the block arity and cause bugs, even though it's only meant as a debug print.
And obviously it doesn't help readability (which still matters to have correct debugging code) and is error-prone.

Sorry, I don't want to reply to the rest of your post.
There is no need to lecture me about Ruby development, I am a long time MRI committer.
The poll is just an indication, not a decision, of course, no one said that.

My main point is the @jeremyevans0 who proposed the syntax, me and @headius which responded on this thread and work on other Ruby implementations and @marcandre
all agree with well explained reasons that we should limit to one argument. It's not just "emotions".

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

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