Issue #8507 has been updated by stephencelis (Stephen Celis). Thanks for weighing in. Given that nil is so prevalent in the language, I don't think we can ignore it. Also, **foo does already exist in the language, and it does do something (validates that the hash acts like kwargs and raises a TypeError if any of they keys aren't symbols. Meanwhile, what if splat were defined as: def splat(foo = {}, **kwargs) p foo, kwargs end What should happen with something like the following? splat(foo: 'bar', a: 'b', **{c: 'd'}) Should it return: [{}, {:foo=>'bar', :a=>'b', :c=>'d'}] Or should it return: [{:foo=>'bar', :a=>'b'}, {:c=>'d'}] Is it something one can easily guess? And what should this do? splat(foo: 'bar', 'baz' => 'fizz', buzz: 'bucket') Heck, what if {**hash_with_string_keys} actually did something like Active Support's symbolize_keys? Right now, the behavior seems ambiguous in general. ---------------------------------------- Bug #8507: Keyword splat does not convert arg to Hash https://bugs.ruby-lang.org/issues/8507#change-40497 Author: stephencelis (Stephen Celis) Status: Feedback Priority: Normal Assignee: matz (Yukihiro Matsumoto) Category: syntax Target version: current: 2.1.0 ruby -v: ruby 2.0.0p195 (2013-05-14 revision 40734) [x86_64-darwin12.3.0] Backport: 1.9.3: UNKNOWN, 2.0.0: UNKNOWN =begin A single splat is useful to convert an object to an array as it passes from one method to the next, so I expected the double-splat to do the same and convert the object to a hash. def splat *args p args end def double_splat **kwargs p args end splat(*nil) # [] splat(**nil) # TypeError: no implicit conversion of nil into Hash For the sake of consistency, wouldn't it make sense to wrap the double-splatted arg with (({Hash()})) the same way a single-splatted arg is wrapped with (({Array()}))? =end -- http://bugs.ruby-lang.org/