From: daniel@...42.com Date: 2019-09-01T01:36:40+00:00 Subject: [ruby-core:94704] [Ruby master Bug#14415] Empty keyword hashes get assigned to ordinal args. Issue #14415 has been updated by Dan0042 (Daniel DeLorme). jeremyevans0 (Jeremy Evans) wrote: > The keyword argument separation changes just made to the master branch did not affect this code, since it isn't a method call. This behavior has been present since Ruby 2.2. I think it would be a good idea to make both `[**({};)]` and `[**(;{})]` return `[]`. Found some other interesting cases which I absolutely don't understand: ```ruby [**(1;{})] #=> [] [**(1+0;{})] #=> [{}] ``` But I must admit I don't really see the benefit to all this, since it only works on hash literals and not hash variables. In what circumstance is it helpful to have a double-splatted empty hash literal in an array??? ---------------------------------------- Bug #14415: Empty keyword hashes get assigned to ordinal args. https://bugs.ruby-lang.org/issues/14415#change-81312 * 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: