From: "mcmire (Elliot Winkler)" <elliot.winkler@...>
Date: 2013-07-12T10:34:06+09:00
Subject: [ruby-core:55964] [ruby-trunk - Bug #8507] Keyword splat does not convert arg to Hash


Issue #8507 has been updated by mcmire (Elliot Winkler).


So let's think about why we have @splat(*nil)@. Ordinarily you wouldn't write this code like that of course, but you might have a variable @foo@ and unbeknownst to you (or perhaps not), @foo@ happens to be @nil@, so you end up with @splat(*nil)@. So I think we're getting a little distracted here by the @nil@.

Let's think about why we use splat at all. We use it because we have an array, and we want to call a method and spread the array across to create a list of arguments. So if @foo@ is @[1, 2, 3]@, @splat(*foo)@ is @splat(1, 2, 3)@.

Why don't we have an equivalent splat syntax for hashes? Well because we don't need it. You can just say @splat(foo)@, assuming @foo@ is a hash, and it just works. What would @splat(**foo)@ even *do*? 

For instance say #splat is defined as:

<pre>
def splat(foo: 'bar', **kwargs)
end
</pre>

Now assuming @foo@ is @{foo: 'bliz', a: 'b', c: 'd'}@, what would @splat(**foo)@ do? Wouldn't this just end up calling @splat(foo: 'bliz', a: 'b', c: 'd')@, and therefore be the same as calling @splat(foo)@?

So while I agree for consistency's sake that @foo(**whatever)@ should do something just as @foo(*whatever)@ does something, I don't really know if this syntax would be used.
----------------------------------------
Bug #8507: Keyword splat does not convert arg to Hash
https://bugs.ruby-lang.org/issues/8507#change-40460

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/