Why are symbols not frozen strings?

Question

I understand the theoretical difference between Strings and Symbols. I understand that Symbols are meant to represent a concept or a name or an identifier or a label or a key, and Strings are a bag of characters. I understand that Strings are mutable and transient, where Symbols are immutable and permanent. I even like how Symbols look different from Strings in my text editor.

What bothers me is that practically speaking, Symbols are so similar to Strings that the fact that they're not implemented as Strings causes a lot of headaches. They don't even support duck-typing or implicit coercion, unlike the other famous "the same but different" couple, Float and Fixnum.

The biggest problem, of course, is that hashes coming into Ruby from other places, like JSON and HTTP CGI, use string keys, not symbol keys, so Ruby programs have to bend over backwards to either convert these up front or at lookup time. The mere existence of HashWithIndifferentAccess, and its rampant use in Rails and other frameworks, demonstrates that there's a problem here, an itch that needs to be scratched.

Can anyone tell me a practical reason why Symbols should not be frozen Strings? Other than "because that's how it's always been done" (historical) or "because symbols are not strings" (begging the question).

Consider the following astonishing behavior:

:apple == "apple"  #=> false, should be true

:apple.hash == "apple".hash #=> false, should be true

{apples: 10}["apples"]  #=> nil, should be 10

{"apples" => 10}[:apples]  #=> nil, should be 10

:apple.object_id == "apple".object_id #=> false, but that's actually fine

All it would take to make the next generation of Rubyists less confused is this:

class Symbol < String
  def initialize *args
    super
    self.freeze
  end

(and a lot of other library-level hacking, but still, not too complicated)

See also:

Update: I think Matz makes the case for class Symbol < String very well here: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/9192 (thanks to Azolo for digging this up, and also Matz' eventual retraction).

excellent question! I remember being plagued by this question when i started learning ruby. However with the passage of time I just forgot about it — sohaibbbhatti
+1 for proper usage of "begging the question" (and a generally clear and well-expressed question) — Phrogz
{apples: 10}["apples"] should be 10? So {1 => "foo"}[1.0] should be "foo", since you mentioned Fixnum and Float as example of classes where it's done "right"? — Michael Kohl
I'm confused. In your first paragraph you lay out a quite detailed explanation of why symbols and strings are fundamentally different, completely dissimilar, absolutely nothing like each other. Then, in the second paragraph you claim that they are almost the same? — Jörg W Mittag
Jörg, they are similar in that if symbols did not exist, their function could be almost entirely duplicated by using (frozen) strings. They are semantically distinct but functionally very similar, and it's surprising to most newcomers that they're not related. Just like JavaScript gets by without an integer type (all JS numbers are floating-point), Ruby could get by without a symbol type. For another example, a Stack is different from an Array, but Matz had no problem adding push and pop to Array; in the same way a string can behave like a symbol (and with no extra methods). — AlexChaffee

Azolo Azolo · Accepted Answer · 2012-06-18T15:52:02

This answer drastically different from my original answer, but I ran into a couple interesting threads on the Ruby mailing list. (Both good reads)

So, at one point in 2006, matz implemented the Symbol class as Symbol < String. Then the Symbol class was stripped down to remove any mutability. So a Symbol was in fact a immutable String.

However, it was reverted. The reason given was

Even though it is highly against DuckTyping, people tend to use case on classes, and Symbol < String often cause serious problems.

So the answer to your question is still: a Symbol is like a String, but it isn't.
The problem isn't that a Symbol shouldn't be String, but instead that it historically wasn't.

Why are symbols not frozen strings?

6 Answers