Issue #2422 has been updated by katz bo. Dave B wrote: >Producing an empty array from a splatted empty array seems unproductive. Agreed. Tanaka Akira wrote: > 2009/12/21 katz bo <redmine / ruby-lang.org>: >> I personally think *[1, 2, 3] should be always unpacked first. > > Your way cannot interpret a = *[]. > > a = *[] > a = > > It is not a valid Ruby statement. Why not think of this as a special case? There's always something special about zeros and nils in my shallow opinion. :P In fact, a = *[] should _exactly_ be a = IMHO. And strictly speaking, a = *[] should not be a valid syntax at all. But, this is Ruby! What does Ruby do with a = *[] ? Let me illustrate an IMO proper way: Ruby looks at *[] and goes, "Fine, let me unpack it." Ruby unpacks *[]. Then Ruby goes, "Nothing? But I can't _carry_ <nothing>! No.. not in an assignment! Wait.. Let's do it!" Ruby marks it as nil. One of the reasons why I think this special case should be handled this way, is the way Ruby handles parallel assignments: a, b = [1] # => [1] p a # => 1 p b # => nil This is not the case, for example, in python. (It spits "ValueError: need more than 1 value to unpack" when you do a, b = [1]). Since Ruby auto-pads the out-of-range elements as nil, we have a good reason to make Ruby automatically handle a = *[] in this way. I also have a vague observation that the splatted array is actually dealt differently by the internal Ruby in some cases. Assignment is such a case. # COMMAND # OUTPUT # RETURN # NOTES p # # => nil p *[] # # => nil # Fits very well in my "unpack first" theory p nil # nil # => nil a = *[]; p a # [] # => [] # ruby 1.9; should both be nil IMO a =* []; p a # [] # => [] # ruby 1.9; should both be nil IMO; the space between * and [ is allowed! Additionally, I find `return' fails my expectations in a similar way assignment does: def foo; return *[]; end; foo # => [] # ruby 1.9; I have doubt: nil or []? def bar; return *[1]; end; bar # => [1] # ruby 1.9; I was expecting 1 def baz; return *[],*[1]; end; baz # => [1] def ban; return *[1],*[2]; end; ban # => [1, 2] def boo; return *[1,2]; end; boo # => [1, 2] We know that return packs multiple parameters into an array. This, combined with my "unpack first" theory, makes me think the first two results are not correct. But I don't know. Can't test it with ruby 1.8 since I don't have it installed. Can somebody post the result to the code above for ruby 1.8? ---------------------------------------- http://redmine.ruby-lang.org/issues/show/2422 ---------------------------------------- http://redmine.ruby-lang.org