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/