[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}, #<Proc:0x00000aa8c0582140 (irb):22>]
```

----------------------------------------
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: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>