From: Daniel da Silva Ferreira <daniel.ferreira@...>
Date: 2014-08-09T04:59:10+01:00
Subject: [ruby-core:64280] Re: [ruby-trunk - Feature #10118] Double splat	for non-symbol keys

Hi,

As far as I know the double splat was introduced in ruby 2.0.
What was the reason behind the design decision?
Does that decision still holds?

I believe the answer to this questions can give a direction to the problem in hands.
I must say I�m very surprised that such behaviour exists and I would be very interested in understanding why it exists as it stands right now.

The differentiation between strings and symbols in hashes causes issues.
We all know that hence the discussion around HashWithIndiferentAccess

Why are we accepting only hashes with symbols as arguments?

Are we aiming to completely stop using strings as hash keys in future releases?

Thanks,

Daniel

On 08 Aug 2014, at 16:08, rr.rosas@gmail.com wrote:

> Issue #10118 has been updated by Rodrigo Rosenfeld Rosas.
> 
> 
> From my point of view the same issues that come from introducing incompatibility come from keeping this confusing behavior where both strings and symbols can be used as identifiers but one have to understand that they are different and not interchangeable.
> 
> If you introduce a few incompatibilities (I don't think there are that many that couldn't be easily fixed for good) then you force a few users to update their code to not expect symbols from behaving differently from strings. I'm still to hear a good use case where this wouldn't be feasible/desired.
> 
> On the other hand, if you don't introduce this small compatibility issue you end up with an increased number of confusion caused by them being different. I counted already a ton of issues in Redmine related to confusions due to symbols and strings not being compatible to each other.
> 
> There's no free solution that would fix all confusions and avoid introducing any backward incompatibilities.
> 
> ----------------------------------------
> Feature #10118: Double splat for non-symbol keys
> https://bugs.ruby-lang.org/issues/10118#change-48259
> 
> * Author: Tsuyoshi Sawada
> * Status: Feedback
> * Priority: Normal
> * Assignee: 
> * Category: 
> * Target version: 
> ----------------------------------------
> The double splat operator ** only seems to work with hashes whose keys are symbols. It will not work when a key is a string, for example. This is true for both ways; for construction:
> 
>    def foo **; end
>    foo(:a => 3) #=> nil
>    foo("a" => 3) #=> ArgumentError: wrong number of arguments (1 for 0)
> 
> and destruction:
> 
>    def bar *; end
>    bar(**{:a => 3}) #=> nil
>    bar(**{"a" => 3}) #=> TypeError: wrong argument type String (expected Symbol)
> 
> This is confusing. I propose that the double splat syntax should be extended so that it works even when the keys are not symbols.
> 
> 
> 
> -- 
> https://bugs.ruby-lang.org/