Issue #15723 has been updated by Dan0042 (Daniel DeLorme).


I would like to add my vote to those in the single-argument camp. I think it's important to remember why this new feature exists in the first place:

mame (Yusuke Endoh) wrote:
> The reason why this feature was introduced, is that people want a shorthand for `ary.map {|x| x.to_i(16) }` and `ary.map {|x| x.to_i.chr }`.

It seems this is the main use case (> 95% imho) and it does not involve multiple arguments. The problem is that the current syntax with numbers puts **emphasis** on multiple arguments.

But I don't understand why everyone insists that @ should refer to only the first argument. That's not how ruby usually works:
``` ruby
[1,2].map{ |x| x }       #=> [1, 2]
{1=>1,2=>2}.map{ |x| x } #=> [[1, 1], [2, 2]]
```
If the block has a single argument `@` should be that argument; if the block has multiple arguments, `@` should be the n-tuple of all arguments, just like a regular block invocation with a single variable. No splat magic necessary. And this makes it simple to use numbering for the few cases where you'd want it:
``` ruby
foo.zip(bar){ @[0] + @[1] }
```


--


But I also *really* like @maedi's proposal:

maedi (Maedi Prichard) wrote:
> jeremyevans0, is it possible to have method/property calls that when without an object, reference the "current item" of the block they are in?
> ```
> posts.each { .author = 'Santa Clause' }
> ```

This makes the common 95% case even more readable/beautiful:
```ruby
ary.map{ .to_i(16) }
ary.map{ .to_i.chr }
#vs
ary.map{ @.to_i(16) }
ary.map{ @.to_i.chr }
#vs
ary.map{ @1.to_i(16) }
ary.map{ @1.to_i.chr }
```

And it's quite easy to use in other situations:


```ruby
posts.map { .*3 }
posts.map { .itself * 3 }
posts.each { puts(.author) }
posts.each { 1..(.author) }
posts.each { 1..(.itself) }
posts.each { foo &(.a) }
foo.zip(bar){ .at(0) + .at(1) }
foo.zip(bar){ .[0] + .[2] }  #currently syntax error; could/should be allowed
```

--

PS: can someone please delete or change the username of @1
It's a dead account and it makes reading this thread rather painful.


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

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