[prev in list] [next in list] [prev in thread] [next in thread] 

List:       ruby-core
Subject:    [ruby-core:92910] [Ruby trunk Misc#15723] Reconsider numbered parameters
From:       konsolebox () gmail ! com
Date:       2019-05-31 12:58:43
Message-ID: redmine.journal-78284.20190531125843.6d59443996c2cbdf () ruby-lang ! org
[Download RAW message or body]

Issue #15723 has been updated by konsolebox (K B).


I prefer the single @ syntax as well.  It will be a huge help since I don't like \
using the (&:method) syntax.  I like avoiding syntax that intuitively makes code \
*unnecessarily* slower without much syntactical benefit, even for a language like \
Ruby.

I think the numbered parameters syntax would be a disaster.  I write shell scripts \
that mangle positional parameters often, but I don't need them, and I don't want them \
in Ruby.  Ruby is an elegant and verbose language.  I hope it's kept that way or at \
least close.


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

* Author: sos4nt (Stefan Schüßler)
* 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>


[prev in list] [next in list] [prev in thread] [next in thread]