Issue #15927 has been updated by shevegen (Robert A. Heiler).


In my own custom, hand-written yaml files I tend to use e. g:

    !ruby/symbol foo: bar

for symbols as keys. This would then lead to this Hash, upon
YAML.load_file:

    x = YAML.load_file 'foo.yml' # => {:foo=>"bar"}

For programmatic generation, YAML.dump() works fine for my use cases.

Converting to/from symbols in ruby is quite easy, including for
Hashes, such as via .transform_keys. 

    hash = { name: "joe", email: "abc / def.com" } # => {:name=>"joe", :email=>"abc / def.com"}
    hash.transform_keys { |k| k.to_s } # => {"name"=>"joe", "email"=>"abc / def.com"}

I guess the issue request focuses in large part on the old debate "String versus Symbols". :)

I like Symbols. I do not remember the full quote, but matz explained the history and 
reason for having Symbols in ruby, in the past; e. g. to use them as (atomic?) identifiers.
The pickaxe book had a slightly different focus, coming from a "symbol keys are more
memory-efficient in Hash keys". When frozen strings were added into ruby, I assume this
old distinction in regards to efficiency became a bit less noticable, but the design
intent is still different between strings and symbols.

I can not speak for anyone else, but I think the distinction between symbols and strings
will be kept for the most part, e. g. symbols will not be changed into being treatable
as strings by default in general. Otherwise I think sawa's advice is good - if you are
in control of the dataset, to manipulate it before, for example, storing it as yaml or
json. 

----------------------------------------
Feature #15927: Allow string keys to be used for String#% and sprintf methods
https://bugs.ruby-lang.org/issues/15927#change-78639

* Author: luke-gru (Luke Gruber)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Right now, in the methods sprintf() and String#%, only symbol keys can be used for named interpolation. For example (from the example documentation):

"foo = %{foo}" % { :foo => 'bar' }        #=> "foo = bar"

String keys do not work like this:

"foo = %{foo}" % { 'foo' => 'bar' }        #=> raises KeyError

I think string keys should work just the same as symbol keys here.

I've created a PR on github for this, perhaps misguidedly, but if can be found here: https://github.com/ruby/ruby/pull/2238

My argument for this feature is that String#gsub() and family works with string keys if given a Hash, for example:

"chocolate ice cream".gsub(/\bc/, { 'c' => 'C' }) #=> 'Chocolate ice Cream'

Also, I don't like having to symbolize keys in strings unnecessarily, but maybe that just goes back to when
Ruby couldn't GC some symbols.





-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>