From: "jeremyevans0 (Jeremy Evans)" Date: 2021-12-27T16:53:26+00:00 Subject: [ruby-core:106841] [Ruby master Bug#18441] Fix inconsistent parentheses with anonymous block forwarding Issue #18441 has been updated by jeremyevans0 (Jeremy Evans). I don't think this is a bug. The issue with not using parentheses is that `&` is going to keep looking for the name for the block variable: ```ruby def a & b b end ``` is parsed as: ```ruby def a(&b) b end ``` So your code: ```ruby def demo positional, & other positional, & end ``` is parsed as: ```ruby def demo(positional, &other positional, &) end ``` Which isn't valid syntax. I'm not sure how we could keep backwards compatibility and also allow for `&` to work the way you want. Note that it is already possible to have anonymous block forwarding work without parentheses, just not exactly the way you want: ```ruby def demo positional, &; other positional, & end def demo positional, &; other positional, &; another positional, & end ``` Note that anonymous block parameter parsing is consistent with anonymous rest and keyword rest parameter parsing from previous versions of Ruby: ```ruby def a * b, ** c, & d [b, c, d] end a(1, b: 2){} # => [[1], {:b=>2}, #] ``` ---------------------------------------- Bug #18441: Fix inconsistent parentheses with anonymous block forwarding https://bugs.ruby-lang.org/issues/18441#change-95652 * Author: bkuhlmann (Brooke Kuhlmann) * Status: Open * Priority: Normal * ruby -v: ruby 3.1.0p0 (2021-12-25 revision fb4df44d16) [arm64-darwin21.2.0] * Backport: 2.6: UNKNOWN, 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- ## Overview One of the best qualities of Ruby, syntactically, is the optional use of parenthesis (or lack there of). I've enjoyed this for almost two decades. With Ruby 3.1.0, things have become a bit more inconsistent with the introduction of anonymous block forwarding. I'm wondering if it would be possible to allow optional parenthesis for this feature? I understand if this can't be done but having consistent behavior would be most welcome. ## Steps to Recreate To demonstrate, consider the following code: ``` ruby def demo positional, &block other positional, &block end ``` Notice parentheses are optional. If saving the above as `snippet.rb` and running as `ruby snippet.rb`, there will be syntax errors. ...but if you modify the above implementation to use anonymous block forwarding as follows: ``` ruby def demo positional, & other positional, & end ``` ...and then run the above as `ruby snippet.rb`, you'll end up with the following syntax error: ``` snippet.rb:16: syntax error, unexpected local variable or method, expecting ';' or '\n' other positional, & ``` In order to fix the error, you'll need to modify the implementation as follows: ``` ruby def demo(positional, &) other positional, & end ``` Should you need to send multiple messages to similar methods within your implementation, you'll be forced to use parentheses within the body as well. Example: ``` ruby def demo(positional, &) other(positional, &) another(positional, &) end ``` It seems odd that the style of code you write needs to differ based on whether you use anonymous or explicit use of block syntax. ## Notes If additional context is helpful, this behavior is similar in nature to an issue with punning as described in this [issue](https://bugs.ruby-lang.org/issues/18396). Anyway, thanks and am enjoying the new Ruby 3.1.0 features! ���� -- https://bugs.ruby-lang.org/ Unsubscribe: