[ruby-dev:51203] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[ruby-dev:51203] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[shugo (Shugo Maeda)]

Issue #19134 has been reported by shugo (Shugo Maeda).

----------------------------------------
Feature #19134: ** is not allowed in def foo(...)
https://bugs.ruby-lang.org/issues/19134

* Author: shugo (Shugo Maeda)
* Status: Open
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
`*` and `&` are allowed in the body of a method with `...` argument forwarding, but `**` is not allowed.

```
def foo(...)
  bar(*) # OK
  baz(&) # OK
  quux(**) # NG
end
```

Is it intended behavior?

It seems that parse.y has code like `#ifdef RUBY3_KEYWORDS`, and if RUBY3_KEYWORDS, `**` will also be supported.




-- 
https://bugs.ruby-lang.org/

[ruby-dev:52003] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[shugo (Shugo Maeda)]

Issue #19134 has been updated by shugo (Shugo Maeda).


I've created a pull request: https://github.com/ruby/ruby/pull/6818

With this change a test of rbs.gem fails because argument types of` def foo(...)` is changed to `(*untyped, **untyped **)` from `(*untyped)`, but I believe it's right.
(however, the specifal variable name `**` should be hidden by rbs.gem.)
I've created a issue: https://github.com/ruby/rbs/issues/1163

----------------------------------------
Feature #19134: ** is not allowed in def foo(...)
https://bugs.ruby-lang.org/issues/19134#change-100289

* Author: shugo (Shugo Maeda)
* Status: Open
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
`*` and `&` are allowed in the body of a method with `...` argument forwarding, but `**` is not allowed.

```
def foo(...)
  bar(*) # OK
  baz(&) # OK
  quux(**) # NG
end
```

Is it intended behavior?

It seems that parse.y has code like `#ifdef RUBY3_KEYWORDS`, and if RUBY3_KEYWORDS, `**` will also be supported.




-- 
https://bugs.ruby-lang.org/

[ruby-dev:52004] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[matz (Yukihiro Matsumoto)]

Issue #19134 has been updated by matz (Yukihiro Matsumoto).


LGTM.

Matz.


----------------------------------------
Feature #19134: ** is not allowed in def foo(...)
https://bugs.ruby-lang.org/issues/19134#change-100293

* Author: shugo (Shugo Maeda)
* Status: Open
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
`*` and `&` are allowed in the body of a method with `...` argument forwarding, but `**` is not allowed.

```
def foo(...)
  bar(*) # OK
  baz(&) # OK
  quux(**) # NG
end
```

Is it intended behavior?

It seems that parse.y has code like `#ifdef RUBY3_KEYWORDS`, and if RUBY3_KEYWORDS, `**` will also be supported.




-- 
https://bugs.ruby-lang.org/

[ruby-dev:52006] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[shugo (Shugo Maeda)]

Issue #19134 has been updated by shugo (Shugo Maeda).


matz (Yukihiro Matsumoto) wrote in #note-2:
> LGTM.

Thank you.  I've merged it.

I realized that my fix also chaged the behavior of the following code:

```ruby
def foo(*, **, &)
  bar(...)
end

def bar(*args, **kw, &block)
  p [args, kw, block&.call]
end

foo(1, 2, x: 3, y: 4) { 5 }
```

My fix changed the result from `[[1, 2], {}, 5]` to `[[1, 2], {:x=>3, :y=>4}, 5]`.
So `...` is now a syntax sugar of `*, **, &`.


----------------------------------------
Feature #19134: ** is not allowed in def foo(...)
https://bugs.ruby-lang.org/issues/19134#change-100306

* Author: shugo (Shugo Maeda)
* Status: Closed
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
`*` and `&` are allowed in the body of a method with `...` argument forwarding, but `**` is not allowed.

```
def foo(...)
  bar(*) # OK
  baz(&) # OK
  quux(**) # NG
end
```

Is it intended behavior?

It seems that parse.y has code like `#ifdef RUBY3_KEYWORDS`, and if RUBY3_KEYWORDS, `**` will also be supported.




-- 
https://bugs.ruby-lang.org/

[ruby-dev:52009] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[Eregon (Benoit Daloze)]

Issue #19134 has been updated by Eregon (Benoit Daloze).


IMHO if `...` is used then `*`, `**` and `&` should all be forbidden (a SyntaxError at parse time).
Because that way is the best for optimizing delegation.
And also taking apart `*` and `**` is arguably not really delegation anymore.

----------------------------------------
Feature #19134: ** is not allowed in def foo(...)
https://bugs.ruby-lang.org/issues/19134#change-100486

* Author: shugo (Shugo Maeda)
* Status: Closed
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
`*` and `&` are allowed in the body of a method with `...` argument forwarding, but `**` is not allowed.

```
def foo(...)
  bar(*) # OK
  baz(&) # OK
  quux(**) # NG
end
```

Is it intended behavior?

It seems that parse.y has code like `#ifdef RUBY3_KEYWORDS`, and if RUBY3_KEYWORDS, `**` will also be supported.




-- 
https://bugs.ruby-lang.org/

[ruby-dev:52010] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[Eregon (Benoit Daloze)]

Issue #19134 has been updated by Eregon (Benoit Daloze).


Although, it should still be possible to optimize delegation as good as possible and allow `*`/`**`/`&` by having those behave like `def args(*,**,&) = *`, `def kwargs(*,**,&) = **`, `def block(*,**,&) = &` and as if `*` was replaced by `args(...)`, etc, but that's of course at the expense of making the handling of those slightly slower and more complicated (but at least it doesn't slow down delegation via `(...)`).

----------------------------------------
Feature #19134: ** is not allowed in def foo(...)
https://bugs.ruby-lang.org/issues/19134#change-100489

* Author: shugo (Shugo Maeda)
* Status: Closed
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
`*` and `&` are allowed in the body of a method with `...` argument forwarding, but `**` is not allowed.

```
def foo(...)
  bar(*) # OK
  baz(&) # OK
  quux(**) # NG
end
```

Is it intended behavior?

It seems that parse.y has code like `#ifdef RUBY3_KEYWORDS`, and if RUBY3_KEYWORDS, `**` will also be supported.




-- 
https://bugs.ruby-lang.org/

[ruby-dev:52011] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[shugo (Shugo Maeda)]

Issue #19134 has been updated by shugo (Shugo Maeda).


Eregon (Benoit Daloze) wrote in #note-5:
> IMHO if `...` is used then `*`, `**` and `&` should all be forbidden (a SyntaxError at parse time).
> Because that way is the best for optimizing delegation.
> And also taking apart `*` and `**` is arguably not really delegation anymore.

`&` is allowed in 3.1, so it's a breaking change to prohibit it.

----------------------------------------
Feature #19134: ** is not allowed in def foo(...)
https://bugs.ruby-lang.org/issues/19134#change-100493

* Author: shugo (Shugo Maeda)
* Status: Closed
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
`*` and `&` are allowed in the body of a method with `...` argument forwarding, but `**` is not allowed.

```
def foo(...)
  bar(*) # OK
  baz(&) # OK
  quux(**) # NG
end
```

Is it intended behavior?

It seems that parse.y has code like `#ifdef RUBY3_KEYWORDS`, and if RUBY3_KEYWORDS, `**` will also be supported.




-- 
https://bugs.ruby-lang.org/

[ruby-dev:52012] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[shugo (Shugo Maeda)]

Issue #19134 has been updated by shugo (Shugo Maeda).

Status changed from Closed to Open

I think it's most conservative to probhibit `*` and `**`:

```
def foo(...)
  bar(&) # OK
  baz(*) # error
  quux(**) # error
end
```

And a error should occur in the following code instead of dropping keyword arguments:

```
def foo(*, **, &)
  bar(...)
end

def bar(*args, **kw, &block)
  p [args, kw, block&.call]
end

foo(1, 2, x: 3, y: 4) { 5 }
```

What do you think, Matz?


----------------------------------------
Feature #19134: ** is not allowed in def foo(...)
https://bugs.ruby-lang.org/issues/19134#change-100495

* Author: shugo (Shugo Maeda)
* Status: Open
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
`*` and `&` are allowed in the body of a method with `...` argument forwarding, but `**` is not allowed.

```
def foo(...)
  bar(*) # OK
  baz(&) # OK
  quux(**) # NG
end
```

Is it intended behavior?

It seems that parse.y has code like `#ifdef RUBY3_KEYWORDS`, and if RUBY3_KEYWORDS, `**` will also be supported.




-- 
https://bugs.ruby-lang.org/

[ruby-dev:52021] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[Eregon (Benoit Daloze)]

Issue #19134 has been updated by Eregon (Benoit Daloze).


shugo (Shugo Maeda) wrote in #note-8:
> `&` is allowed in 3.1, so it's a breaking change to prohibit it.

Right and `&` is not problematic re performance, it's a completely separate argument anyway.
I agree with your proposal in your comment just above this one.


----------------------------------------
Feature #19134: ** is not allowed in def foo(...)
https://bugs.ruby-lang.org/issues/19134#change-100573

* Author: shugo (Shugo Maeda)
* Status: Open
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
* Target version: 3.2
----------------------------------------
`*` and `&` are allowed in the body of a method with `...` argument forwarding, but `**` is not allowed.

```
def foo(...)
  bar(*) # OK
  baz(&) # OK
  quux(**) # NG
end
```

Is it intended behavior?

It seems that parse.y has code like `#ifdef RUBY3_KEYWORDS`, and if RUBY3_KEYWORDS, `**` will also be supported.




-- 
https://bugs.ruby-lang.org/

[ruby-dev:52025] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[mame (Yusuke Endoh)]

Issue #19134 has been updated by mame (Yusuke Endoh).


> IMHO if ... is used then *, ** and & should all be forbidden (a SyntaxError at parse time).

I agree with this. If you want to do that, you should take it with `def foo(*, **, &)`.

I feel that only `&` is acceptable since a block is implicitly passed. But I don't think `*` and `**` make sense inside `def foo(...)`.

----------------------------------------
Feature #19134: ** is not allowed in def foo(...)
https://bugs.ruby-lang.org/issues/19134#change-100630

* Author: shugo (Shugo Maeda)
* Status: Open
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
* Target version: 3.2
----------------------------------------
`*` and `&` are allowed in the body of a method with `...` argument forwarding, but `**` is not allowed.

```
def foo(...)
  bar(*) # OK
  baz(&) # OK
  quux(**) # NG
end
```

Is it intended behavior?

It seems that parse.y has code like `#ifdef RUBY3_KEYWORDS`, and if RUBY3_KEYWORDS, `**` will also be supported.




-- 
https://bugs.ruby-lang.org/

[ruby-dev:52027] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[shugo (Shugo Maeda)]

Issue #19134 has been updated by shugo (Shugo Maeda).


mame (Yusuke Endoh) wrote in #note-12:
> I feel that only `&` is acceptable since a block is implicitly passed. But I don't think `*` and `**` make sense inside `def foo(...)`.

Speaking of implicity of blocks, `def f; g(&); end` causes a syntax error, so it may be better to allow it, or disallow `def f(...); g(&); end` in the future versions.
Anyway, I've fixed the behavior of `...` as described in #note-9.

----------------------------------------
Feature #19134: ** is not allowed in def foo(...)
https://bugs.ruby-lang.org/issues/19134#change-100678

* Author: shugo (Shugo Maeda)
* Status: Closed
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
* Target version: 3.2
----------------------------------------
`*` and `&` are allowed in the body of a method with `...` argument forwarding, but `**` is not allowed.

```
def foo(...)
  bar(*) # OK
  baz(&) # OK
  quux(**) # NG
end
```

Is it intended behavior?

It seems that parse.y has code like `#ifdef RUBY3_KEYWORDS`, and if RUBY3_KEYWORDS, `**` will also be supported.




-- 
https://bugs.ruby-lang.org/

[ruby-dev:52028] [Ruby master Feature#19134] ** is not allowed in def foo(...)

[Eregon (Benoit Daloze)]

Issue #19134 has been updated by Eregon (Benoit Daloze).


shugo (Shugo Maeda) wrote in #note-14:
> Speaking of implicity of blocks, `def f; g(&); end` causes a syntax error, so it may be better to allow it, or disallow `def f(...); g(&); end` in the future versions.

Since some time @ko1 worked on no implicit block if not a parameter of the method (with the exception of `yield` in the body). I think that's a good property, so I think it's good for `def f; g(&); end` to be a syntax error.

For `def f(...); g(&); end` "..." is "capture all arguments, positional, keyword and block" so I think it's more natural there to be able to access the block (although I can't think of when that would be useful, maybe `def f(...); g(&); h(...) end` when `h` is known to ignore the block but that feels hacky, better use `(*, **, &)` parameters then).

> Anyway, I've fixed the behavior of `...` as described in #note-9.

Thanks!

----------------------------------------
Feature #19134: ** is not allowed in def foo(...)
https://bugs.ruby-lang.org/issues/19134#change-100680

* Author: shugo (Shugo Maeda)
* Status: Closed
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
* Target version: 3.2
----------------------------------------
`*` and `&` are allowed in the body of a method with `...` argument forwarding, but `**` is not allowed.

```
def foo(...)
  bar(*) # OK
  baz(&) # OK
  quux(**) # NG
end
```

Is it intended behavior?

It seems that parse.y has code like `#ifdef RUBY3_KEYWORDS`, and if RUBY3_KEYWORDS, `**` will also be supported.




-- 
https://bugs.ruby-lang.org/