From: josh.cheek@... Date: 2018-01-29T03:04:21+00:00 Subject: [ruby-core:85203] [Ruby trunk Bug#14415] Empty keyword hashes get assigned to ordinal args. Issue #14415 has been updated by josh.cheek (Josh Cheek). Was thinking about this more, and I *think* I see what the problem is: `**` should not be `kwrest`, it should be `options_rest`. And keyword args should be about destructuring the options hash. In the case of mixed keys in the hash, they are valid options to pass to `**var`, even though they cannot be destructured. Here are some examples: ~~~ruby # This behaves correctly: if you destructure the options hash, # than anything not accounted for should explode -> a='a', b:'b' { [a, b] }.call a: 2, b: 3 rescue $! # => # # This should have done what the previous example did. # Instead, it pulls `{1=>2}` out and assigns it to `a` -> a='a', b:'b' { [a, b] }.call 1 => 2, b: 3 # => [{1=>2}, 3] # This is the same as the previous example, but without the `{1=>2}` # it behaves correctly. -> a='a', b:'b' { [a, b] }.call b: 3 # => ["a", 3] # Here, the parameters make no use of keywords, so we correctly # treat it like a hash, from the Ruby of old. -> a { a }.call b: 3 # => {:b=>3} # This should be an argument error, the method receives an options hash, # an options hash was passed, so `{b:3}` should be assigned to `b`, and # the missing argument `a` should cause an explosion. -> a, **b { [a, b] }.call b: 3 # => [{:b=>3}, {}] ~~~ ---------------------------------------- Bug #14415: Empty keyword hashes get assigned to ordinal args. https://bugs.ruby-lang.org/issues/14415#change-69950 * Author: josh.cheek (Josh Cheek) * Status: Open * Priority: Normal * Assignee: * Target version: * ruby -v: ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin17] * Backport: 2.3: UNKNOWN, 2.4: UNKNOWN, 2.5: UNKNOWN ---------------------------------------- Spreading empty arrays works, even when they go through a variable, or are disguised: ~~~ruby args = [] # => [] ->{}.call *[] # => nil ->{}.call *args # => nil ->{}.call *([]) # => nil ->{}.call *([];) # => nil ->{}.call *(;[]) # => nil ->{}.call *[*[]] # => nil ->{}.call *([];[]) # => nil ->{}.call *[*args] # => nil ~~~ Spreading empty keywords does not, when going through a variable, or sufficiently disguised: ~~~ruby kws = {} # => {} ->{}.call **{} # => nil ->{}.call **kws rescue $! # => # ->{}.call **({}) # => nil ->{}.call **({};) # => nil ->{}.call **(;{}) rescue $! # => # ->{}.call **{**{}} # => nil ->{}.call **({};{}) rescue $! # => # ->{}.call **{**kws} rescue $! # => # ~~~ It seems that `**{}` gets optimized out of the code, as expected. Likely due to https://bugs.ruby-lang.org/issues/10719 But `**empty_kws` still gets incorrectly passed as a hash, despite an attempt to fix it in https://bugs.ruby-lang.org/issues/13717 ~~~ruby ->a{a}.call **{} rescue $! # => # ->a{a}.call **kws # => {} ->a{a}.call **(;{}) # => {} (;{}) # => {} ~~~ Further confusion, it's missing `a`, not `b`: ~~~ruby ->a,b:{}.call **{b:1} rescue $! # => # ~~~ Treating keywords as a special form of hash makes them very difficult to reason about. Arrays manage to pull off destructuring and spreading with no issue, as we saw above. I just want hashes to work like arrays with named matching instead of ordinal matching. For each example below, try looking at the LHS and predicting what the result will be. ~~~ruby ->a,b:,**c{[a,b,c]}.call 1, b:2 # => [1, 2, {}] ->a,b:,**c{[a,b,c]}.call 1, b:2, 3=>4 rescue $! # => # ->a,b:,**c{[a,b,c]}.call 1=>2, b:3 rescue $! # => # ->a,b:,**c{[a,b,c]}.call 1=>2, **{b:3} rescue $! # => # ->a,b:,**c{[a,b,c]}.call({1=>2}, b: 3) # => [{1=>2}, 3, {}] ->a,b:,**c{[a,b,c]}.call({1=>2}, {b: 3}) # => [{1=>2}, 3, {}] ->*a {a }.call 1, b:2, c:3, 4=>5 # => [1, {:b=>2, :c=>3, 4=>5}] ->*a,b:,**c{[a,b,c]}.call 1, b:2, c:3, 4=>5 # => [[1, {4=>5}], 2, {:c=>3}] ~~~ Keywords are getting in the way of beautiful hash spreading! ~~~ruby [*[1,2], *[:c, :d]] # => [1, 2, :c, :d] {**{1=>2}, **{c: :d}} rescue $! # => # [1,2,**{a:3}] # => [1, 2, {:a=>3}] [1,2,**{}] # => [1, 2] [1,2,**kws] # => [1, 2, {}] ~~~ Note that the latest JS's behaviour is congruent with my expected outputs: ~~~sh $ node -v # >> v8.9.4 $ node -p ' (({a, c, ...rest}) => [a, c, rest]) ({a: 1, b: 2, c: 3, d: 4}) ' # >> [ 1, 3, { b: 2, d: 4 } ] $ node -p ' const a=1, b=2, e={f: 5, g: 6} ;({...{a, b}, ...{c: 3, d: 4}, ...e}) ' # >> { a: 1, b: 2, c: 3, d: 4, f: 5, g: 6 } ~~~ -- https://bugs.ruby-lang.org/ Unsubscribe: