Random Hacks: 13 Ways of Looking at a Ruby Symbol

"13 Ways of Looking at a Ruby Symbol" by Eric Kidd

Thu, 08 Feb 2007 07:37:10 +0000

Over the years, quite a few people have asked me, “What is symbol?” I usually tell them, “A symbol is a name.” And for some people, this clicks instantly.

Other people quite sensibly reply, “Well, why is there one kind of strings for ‘names,’ and another kind of strings for, well, strings? How do I decide when to use which?”

And those aren’t such easy questions to answer. Rails confuses the question further by making symbols and strings pretty much interchangeable.

What I’ve found is that different explanations work for different people. One programmer said, “Oh! They’re just enumeration labels! That makes sense.” And when I was a novice Lisp programmer, #10 was the one that made things click for me.

So please, take whatever explanation works for you, and ignore the rest. And if you’d prefer a simpler explanation, one which only focuses on a single aspect of symbols, please feel free to link to it from the comment thread!

"13 Ways of Looking at a Ruby Symbol" by Charles Oliver Nutter

Thu, 08 Feb 2007 02:53:36 +0000

Austin: I think you must have meant #13 is not true for JRuby, because obviously #12 must be. Just wanted to clarify that for anyone reading…

And I agree that Symbols are names. That’s how I describe them, and it’s a core reason I argued against making them < String.

"13 Ways of Looking at a Ruby Symbol" by Austin Ziegler

Wed, 07 Feb 2007 23:58:18 +0000

I can’t disagree more, Michael. The reality is that the more attention that is paid to what a Symbol is, the less attention is paid to the intent. Symbols aren’t magic. They’re not complex. Talking about how they’re implemented is, for most people and especially Rails folks, unnecessary and confusing.

Symbols are names. That’s all that matters. Saying anything more than that while trying to define a Symbol is a fruitless exercise. What’s in a name? The meaning one gives to it. You could call me “Betty”, but that doesn’t mean that I’d respond to it—it doesn’t have meaning to me.

Ten of the ways (1, 2, 5 – 10, 12) are simply ways of saying exactly what #3 says, and they’re less useful because they try to make comparisons that deal with HOW Symbols are used, not WHAT they are. #11 is important to know about dynamically generating symbols (an implication, if you will), and #12 matters ONLY to people who are diving under the covers of Ruby into its implementation. (It’s not true in any case, for JRuby, which is a damned good argument for not including it.)

"13 Ways of Looking at a Ruby Symbol" by Michael

Tue, 06 Feb 2007 23:28:46 +0000

Actually, Austin, I think Eric’s post goes a long way to removing a sense of complexity and “magic” from some people’s interpretation of the symbol as a data structure, and I would argue he provides some very helpful perspectives. To some, these views may seem obvious; but everything is obvious once you’ve seen it.

As with many of the basic features of any programming language, symbols are a simple idea that gains a kind of complexity by virtue of its generality. Therefore, I think there is real value in exploring many different views of the same simple concept, even though doing so does not change its intrinsic simplicity.

"13 Ways of Looking at a Ruby Symbol" by Austin Ziegler

Tue, 06 Feb 2007 22:40:43 +0000

Um. I think that this makes post makes Symbol objects far more complex and magical than they really are. They’re not magic. There’s a few interesting facts about them (there’s only one copy of a given symbol; they’re not currently garbage-collectable; how they’re implemented in C), but nothing else really helps people understand Symbols.

I said it in the O’Reilly blog months ago, there’s nothing magical or special about Symbols. It’s in the intent of the call you’re making. What’s magic in “attr_accessor :foo” is not :foo, but “attr_accessor”.

Anonymous Cow, matz has backed off from that proposal, if I remember correctly.

"13 Ways of Looking at a Ruby Symbol" by Anonymous Cow

Mon, 05 Feb 2007 21:39:39 +0000

But I hear tell that in 2.0, Symbols will be strings, oh my!

(Though, they will be thoroughly frozen, as to not harm the children of the world).

"13 Ways of Looking at a Ruby Symbol" by Eric Kidd

Mon, 05 Feb 2007 19:57:11 +0000

Murray: Yes, the code in number 7 is extremely useless. :-)

"13 Ways of Looking at a Ruby Symbol" by Murray Spork

Mon, 05 Feb 2007 19:43:48 +0000

2nd array element is (now correctly escaped):
#<Method: Demo#say>

"13 Ways of Looking at a Ruby Symbol" by Murray Spork

Mon, 05 Feb 2007 19:27:12 +0000

Regarding no.7 – not sure if I got the point entirely – but for the 2nd item in the arrary returned by look_up_with_symbols be:

method(:say).call

Otherwise you get the following array returned:

=> [“Hello”, #, “Hello”]

"13 Ways of Looking at a Ruby Symbol" by Eric Kidd

Fri, 02 Feb 2007 19:39:12 +0000

Thanks for the suggestion! Here’s a sample function with keyword arguments in Ruby:

def foo opts={}
  bar = opts[:bar] || 1
  baz = opts[:baz] || 2
  puts baz
end

foo :baz => 3

This is a little clunky, but it works nicely enough in practice.

"13 Ways of Looking at a Ruby Symbol" by Peter Burns

Fri, 02 Feb 2007 18:30:12 +0000

You might want to go into more detail about using symbols for keyword arguments. That’s just using a convenient way that Ruby deals with hashes at the end of argument lists.

For example: http://api.rubyonrails.org/classes/ActionController/Base.html#M000261

The way you have it seems misleading to someone new to Ruby, suggesting that

def foo(bar=1,baz=2)
  puts baz
end

foo :baz => 3 #=> prints:   2

would output 3. Rails is just using an options hash at the end of parameter lists to do something like named arguments.

"13 Ways of Looking at a Ruby Symbol" by Eric Kidd

Fri, 02 Feb 2007 12:58:53 +0000

Thanks! Fixed it.

"13 Ways of Looking at a Ruby Symbol" by Michael Chermside

Fri, 02 Feb 2007 11:24:04 +0000

“In Ruby, we can convert a symbol to a string using intern:” should read “In Ruby, we can convert a string to a symbol using intern:” instead.

13 Ways of Looking at a Ruby Symbol

Eric Kidd — Sat, 20 Jan 2007 03:20:00 +0000

New Ruby programmers often ask, “What, exactly, is a symbol? And how does it differ from a string?” No one answer works for everybody, so–with apologies to Wallace Stevens–here are 13 ways of looking at a Ruby symbol.