Issue #15723 has been updated by phluid61 (Matthew Kerwin).


Eregon (Benoit Daloze) wrote:
> 
> TBH, I didn't see many comments in favor of multiple block arguments.
> It would be good if supporters of that would comment here.
> To me, it sounds like most people do not want them or are convinced by the arguments above it's not worth it.
> So a proposal to remove @2 and above just makes sense, isn't it?

What about those of us who don't like the current trend in Ruby of turning everything into a shorter, harder-to-grok jumble of non-alphanumeric symbols?  Or is that just me?

WRT to the issue at hand:

* I agree, if there are more than one block args you should explicitly name them.
* I agree, if there is just one and you're doing a simple operation, the overhead of capturing the arg in a named variable and then operating on it makes it harder to *write*.
* I don't think `{|x| x ** 2 }` is any harder to *read* than `{ @ ** 2 }`, and I could get used to reading the latter.
* I think `-> x { x ** 2 }` and `-> { @ ** 2 }` are both ASCII soup, so there's no winning there.
* Lone `@` *feels* bad, but maybe that's good because it makes people reluctant to use it except when it's really advantageous otherwise.

Consider that a voice in support of this ticket, I guess.

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

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