- ruby-dev - ml.ruby-lang.org

[ruby-dev:52027] [Ruby master Feature#19134] ** is not allowed in def foo(...)
by shugo (Shugo Maeda) 15 Dec '22

15 Dec '22

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/

1 0

[ruby-dev:52025] [Ruby master Feature#19134] ** is not allowed in def foo(...)
by mame (Yusuke Endoh) 13 Dec '22

13 Dec '22

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/

1 0

[ruby-dev:52021] [Ruby master Feature#19134] ** is not allowed in def foo(...)
by Eregon (Benoit Daloze) 12 Dec '22

12 Dec '22

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/

1 0

[ruby-dev:52029]
by Masaki Murano 11 Dec '22

11 Dec '22

unsubscribe

1 0

[ruby-dev:52012] [Ruby master Feature#19134] ** is not allowed in def foo(...)
by shugo (Shugo Maeda) 04 Dec '22

04 Dec '22

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/

1 0

[ruby-dev:52011] [Ruby master Feature#19134] ** is not allowed in def foo(...)
by shugo (Shugo Maeda) 04 Dec '22

04 Dec '22

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/

1 0

[ruby-dev:52010] [Ruby master Feature#19134] ** is not allowed in def foo(...)
by Eregon (Benoit Daloze) 04 Dec '22

04 Dec '22

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/

1 0

[ruby-dev:52009] [Ruby master Feature#19134] ** is not allowed in def foo(...)
by Eregon (Benoit Daloze) 04 Dec '22

04 Dec '22

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/

1 0

[ruby-dev:52007] [Ruby master Feature#19163] Data object should be frozen
by matz (Yukihiro Matsumoto) 01 Dec '22

01 Dec '22

Issue #19163 has been reported by matz (Yukihiro Matsumoto). ---------------------------------------- Feature #19163: Data object should be frozen https://bugs.ruby-lang.org/issues/19163 * Author: matz (Yukihiro Matsumoto) * Status: Open * Priority: Normal ---------------------------------------- If we call `initialize` (via `send`), we can rewrite an existing Data object. ```ruby d=Data.define(:a, :b).new(1,2) p d #=> #<data a=1, b=2> d.send(:initialize, {a:3,b:4}) p d #=> #<data a=3, b=4> ``` Should we freeze the Data object after calling `initialize` for the first time? Matz. -- https://bugs.ruby-lang.org/

2 1

[ruby-dev:52006] [Ruby master Feature#19134] ** is not allowed in def foo(...)
by shugo (Shugo Maeda) 28 Nov '22

28 Nov '22

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/

1 0