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


Since I wasn't at the developer meeting I'll post my thoughts/responses to the log here.

> matz: I prefer this style to .map(&:to_s). But I understand it is not flexible enough. Difficult to determine.

This shorthand simplifies one of the most common block idioms, no more no less (dotadiw). IMHO it's meant to be elegant rather than flexible; for flexibility one should always use the regular block syntax.

> shevegen: if I were to have a say, my personal opinion is -1 on the proposal as such, even though oddly enough I also like it at the same time

That's... an interesting paradox. I would say to you (and matz): just trust your gut feeling on this and accept that it "looks really nice" without overanalyzing :-)

> mame: If this style is accepted, Symbol#to_proc is deprecated? It sounds good.
> matz: Sounds like a plan.

I'm pretty sure everyone will voluntarily switch from `(&:to_s)` to `{.to_s}` but even so is there really a need to go so far as to deprecate Symbol#to_proc ?

> someone: Can we write 1.times { .foo; any-statement }?
> matz: No

I have no idea why someone would want to write this, but why is there a need to disallow it? The shorthand is simpler to explain and implement if it's just `{.foo` is equivalent to `{|x|x.foo`, without special exceptions or restrictions to account for.

> nobu: It is difficult to implementí─ Currently my patch even allows 1.times { .foo(.bar) }
> matz: No

Wow, I did not realize your patch allowed that! I think it's safer if it's only at the beginning of the block. I've tried writing a patch for that. Please forgive if it's too hacky. https://github.com/dan42/ruby/commit/51e5fa4d4a56c29e5f0ceb1e5544822e9215148f (It crashes Ripper though)

----------------------------------------
Feature #16120: Omitted block argument if block starts with dot-method call
https://bugs.ruby-lang.org/issues/16120#change-81675

* Author: Dan0042 (Daniel DeLorme)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
How about considering this syntax for implicit block parameter:
```
[10, 20, 30].map{ .to_s(16) }  #=> ["a", "14", "1e"]
```
Infinite thanks to @maedi for [the idea](https://bugs.ruby-lang.org/issues/15723#note-19)

This proposal is related to #4475, #8987, #9076, #10318, #10394, #10829, #12115, #15302, #15483, #15723, #15799, #15897, #16113 (and probably many others) which I feel are all trying to solve the same "problem". So I strongly believe all these feature requests should to be considered together in order to make a decision. And then closed together.

This "problem" can be more-or-less stated thus:
* There is a very common pattern in ruby: `posts.map{ |post| post.author.name }`
* In that line, the three 3 "post" in close proximity feel redundant and not DRY.
* To reduce the verbosity, people tend to use a meaningless one-character variable in the block
* But even so `posts.map{ |p| p.author.name }` still feels redundant.
* This "problem" is felt by many in the ruby community, and is the reason people often prefer `posts.map(&:author)`
* But that only works for one method with no arguments.
* This results in many requests for a block shorthand than can do more.

I realize that many people feel this is not a problem at all and keep saying "just use regular block syntax". But the repeated requests over the years, as well as the widespread usage of `(&:to_s)`, definitely indicate this is a wish/need for a lot of people.

Rather than adding to #15723 or #15897, I chose to make this a separate proposal because, unlike `it` or `@` implicit variables, it allows to simplify **only** `{ |x| x.foo }`, not `{ |x| foo(x) }`. This is on purpose and, in my opinion, a desirable limitation.

The advantages are (all in my opinion, of course)
* Extremely readable: `posts.map{ .author.name }`
   * Possibly even more than with an explicit variable.
* Of all proposals this handles the most important use-case with the most elegant syntax.
   * It's better to have a beautiful shorthand for 90% of cases than a non-beautiful shorthand for 100% of cases.
   * A shorthand notation is less needed for `{ |x| foo(x) }` since the two `x` variables are further apart and don't feel so redundant.
* No ascii soup
* No potential incompatibility like `_` or `it` or `item`
* Very simple to implement; there's just an implicit `|var| var` at the beginning of the block.
* In a way it's similar to chaining methods on multiple lines:

        posts.map{ |post| post
          .author.name
        }

It may be interesting to consider that the various proposals are not *necessarily* mutually exclusive. You *could* have `[1,2,3].map{ .itself + @ + @1 }`. Theoretically.

I feel like I've wanted something like this for most of the 16 years I've been coding ruby. Like... **this** is what I wanted that `(&:to_s)` could only deliver half-way. I predict that if this syntax is accepted, most people using `(&:to_s)` will switch to this.




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