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 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 Schüßler) > * 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 – 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. > > > > -- > https://bugs.ruby-lang.org/ > > Unsubscribe: > >