Issue #10708 has been updated by David Unric.


If I am not mistaken, even latest Ruby 2.2 selects keyword arguments as thelast method's argument and of Hash type.

Let's imagine an example where both simple and keyword optional arguments are used:

~~~
def call_multiargs(method, *aopts, **kwopts); send(method, *aopts, **kwopts); end
# kwopts can be passed to send method without double-splat operator as it does _nothing_ here

def args_and_kwargs(*args, **kwargs); p args; p kwargs; end

call_multiargs(:args_and_kwargs, **{a: 1, b:2})
# How should Ruby expand the hash ?
#   - as (:a, 1, :b, 2) list so kwopts would be empty {} ?
#   - as (:a, 1) and {b: 2} so kwopts would be {b: 2} ?
#   - as {a: 1, b:2} so aopts would be empty [] ?
#   - as ([:a, 1], [:b, 2]) list and kwopts would be empty {} ?
#   - as ([:a, 1]) and {:b, 2} ?
#   etc
~~~

Because Ruby has no special keyword list type like Python has and for keyword arguments a single Hash instance is used, it is fundamentally not possible to do an expansion of `**{กฤ}` into a list.
Again, in Ruby there does not exist a list of type `:a => 1, :b => 2`. What you see in a method call is a syntactic sugar for `{:a => 1, :b =>2}`, ie. optional braces.
To keep consistency there can't exist an exception to this rule for empty hashes.

To sum it up, use of double-splat operator for hash expansion is wrong and makes no sense.

p.s. As far as I know, there are only two cases and only as a parser syntaxhelpers for Hash and Array constructors, quite unrelated to some list expansion:
`{**{:a => 1, :b => 2}}` - enclosed hash items used for implicit form
`[*{:a => 1, :b => 2}]`  - enclosed hash converted with Hash#to_a and used for implicit form


----------------------------------------
Bug #10708: In a function call, double splat of an empty hash still calls the function with an argument
https://bugs.ruby-lang.org/issues/10708#change-50869

* Author: Damien Robert
* Status: Open
* Priority: Normal
* Assignee: 
* Category: 
* Target version: 
* ruby -v: ruby 2.2.0p0 (2014-12-25 revision 49005) [x86_64-linux]
* Backport: 2.0.0: UNKNOWN, 2.1: UNKNOWN, 2.2: UNKNOWN
----------------------------------------
Consider this:
    def foo; end
    foo(*[]) #Splatting an empty list is ok
    foo(**{}) #Double splatting an empty hash is like calling foo({}) whichgives an error

This is annoying in a function that is a wrapper around another function and just process some keywords:
    def wrapper(*args, keyword: true, **others)
      puts keyword
      wrappee(*args,**others) #here this code will fail if others is empty
    end



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