That's great news. It makes more sense for a single argument. `@` on its
own should be enough. But why it can't be like this? `@[0]` I think its
more clear :)



On Wed, Apr 17, 2019 at 2:13 PM <merch-redmine / jeremyevans.net> wrote:

> Issue #15723 has been updated by jeremyevans0 (Jeremy Evans).
>
>
> As I expressed in the developer meeting today, after a lot of thought, I
> believe if we want to support implicit block arguments, we should limit
> support to a single argument, and use `@` to represent the argument.
>
> As Marc showed, blocks that accept a single argument are much more popular
> than blocks that accept more than one argument.  For blocks that accept
> multiple arguments, referencing the arguments by position rather than by
> name will make the code less understandable, not more.
>
> Most of the objections with `@` in regards to syntax are because the
> references look like instance variables, and most Rubyists do not know that
> `@1` is not a valid instance variable.  Using a bare `@` should avoid or at
> least mitigate that problem.  I don't know if there is a sigil other than
> `@` that will work. `\` worked for the case where you are using a position
> number, but it will not work without that, because then it can be
> interpreted as a line continuation.  `%` and similar sigils that are binary
> operators cannot be used because they will be interpreted as a binary
> operator:
>
> ```ruby
> proc do
>   foo %
>   bar
> end
> # parsed as proc{foo().%(bar())}
> ```
>
> ----------------------------------------
> Misc #15723: Reconsider numbered parameters
> https://bugs.ruby-lang.org/issues/15723#change-77660
>
> * Author: sos4nt (Stefan Schler)
> * Status: Feedback
> * Priority: Normal
> * Assignee:
> ----------------------------------------
> 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  Ican
> *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.
>
>
>
> --
> 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>
>
(supressed text/html)
Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>