# Trying to understand symbols **URL:** \ **Category:** ruby-talk\ **Created:** [25 July 2005 23:35 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741 "2005-07-25T23:35:58Z")\ **Posts on this page:** 18\ **Page:** 1
**Author:** ![Sam\_Kong](https://avatars.discourse-cdn.com/v4/letter/s/ad7895/32.png) [@Sam\_Kong](https://rubytalk.org/u/Sam_Kong)\ **Post date:** [25 July 2005 23:35 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/1 "2005-07-25T23:35:58Z")
Hello! I don't fully understand symbols in Ruby even if I've read books and postings here. Symbols are often compared to strings like the following. h1 = {:a =\> 1} #symbol. faster and immutable. h2 = {'a' =\> 1} Ok, I can understand that. Now, is the term 'symbol' used the same meaning in the following text (from PickAxe2 page 314)? \ When Ruby sees a name such as a in an expression, it needs to determine if it is a local variable reference or a call to a method with no parameters. To decide which is the case, Ruby uses a heuristic. As Ruby parses a source file, it keeps track of symbols that have been assigned to. It assumes that these symbols are variables. When it subsequently comes across a symbol that could be a variable or a method call, it checks to see if it has seen a prior assignment to that symbol. If so, it treats the symbol as a variable; otherwise it treats it as a method call. As a somewhat pathological case of this, consider the following code fragment, submitted by Clemens Hintze. \ Before I met Ruby, I regarded 'symbol' as the one in the text. But Ruby's symbol seems to have its unique meaning and usage. Can anybody clarify that? Thanks. Sam ---
**Author:** ![Jacob\_Fugal](https://avatars.discourse-cdn.com/v4/letter/j/439d5e/32.png) [@Jacob\_Fugal](https://rubytalk.org/u/Jacob_Fugal)\ **Post date:** [25 July 2005 23:43 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/2 "2005-07-25T23:43:38Z")
No, they are not the same. The latter is the general meaning of symbol in a parser context. The former is a specific type of value in Ruby. Jacob Fugal > **···** > > On 7/25/05, Sam Kong \ wrote: > > > Symbols are often compared to strings like the following. > > > > h1 = {:a =\> 1} #symbol. faster and immutable. > > h2 = {'a' =\> 1} > > > > Ok, I can understand that. > > Now, is the term 'symbol' used the same meaning in the following text > > (from PickAxe2 page 314)? > > > > \ > > When Ruby sees a name such as a in an expression, it needs to determine > > if it is a local variable reference or a call to a method with no parameters. To > > decide which is the case, Ruby uses a heuristic. As Ruby parses a source > > file, it keeps track of symbols that have been assigned to.... > > \ ---
**Author:** ![Lennon\_Day-Reynolds1](https://avatars.discourse-cdn.com/v4/letter/l/5f8ce5/32.png) [@Lennon\_Day-Reynolds1](https://rubytalk.org/u/Lennon_Day-Reynolds1)\ **Post date:** [25 July 2005 23:46 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/3 "2005-07-25T23:46:03Z")
You are correct to think these two usages of 'symbol' are conflicting -- if it helps, in the text you quote from p. 314, replace the word 'symbol' with 'name'. It's just a mis-match in terminology: in parser/compiler-speak, a 'symbol' is just a type of token, not a special kind of immutable string like it is in Ruby. Hope that helps, Lennon ---
**Author:** ![David\_A\_Black3](https://avatars.discourse-cdn.com/v4/letter/d/6a8cbe/32.png) [@David\_A\_Black3](https://rubytalk.org/u/David_A_Black3)\ **Post date:** [25 July 2005 23:57 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/4 "2005-07-25T23:57:08Z")
Hi -- > Before I met Ruby, I regarded 'symbol' as the one in the text. > But Ruby's symbol seems to have its unique meaning and usage. > Can anybody clarify that? A symbol object, like :x, is different from what one might generically call a symbol. So here:    sym = :x sym is a symbol in a generic or general sense, whereas :x is an instance of class Symbol. When people talk about things like using symbols as hash keys, they mean instances of Symbol -- :x and things like that. It's common usage to call things like sym (above) symbols too, so there's some overloading of the term. David > **···** > > On Tue, 26 Jul 2005, Sam Kong wrote: > > -- > David A. Black > dblack@wobblini.net ---
**Author:** ![Sam\_Kong](https://avatars.discourse-cdn.com/v4/letter/s/ad7895/32.png) [@Sam\_Kong](https://rubytalk.org/u/Sam_Kong)\ **Post date:** [26 July 2005 00:01 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/5 "2005-07-26T00:01:04Z")
Thanks, rcoder! But, what bothers me is the following case. class Foo    def foo      puts "foo"    end end Foo.new.send(:foo) In this case, :foo is not just a string-like thing. It seems more like the one in the quoted text. What do you think? Sam ---
**Author:** ![Sam\_Kong](https://avatars.discourse-cdn.com/v4/letter/s/ad7895/32.png) [@Sam\_Kong](https://rubytalk.org/u/Sam_Kong)\ **Post date:** [26 July 2005 00:06 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/6 "2005-07-26T00:06:02Z")
Thanks David! David A. Black wrote: > sym is a symbol in a generic or general sense, whereas :x is an > instance of class Symbol. When people talk about things like using > symbols as hash keys, they mean instances of Symbol -- :x and things > like that. It's common usage to call things like sym (above) symbols > too, so there's some overloading of the term. Your explanation made it clear! One more think to clear up. f.send(:foo) #\<- is :foo a symbol like an instance of Symbol or just a generic symbol? If :foo is not an instance of Symbol, then ':' is used for 2 kinds of things in Ruby, right? Thanks. Sam ---
**Author:** ![David\_A\_Black3](https://avatars.discourse-cdn.com/v4/letter/d/6a8cbe/32.png) [@David\_A\_Black3](https://rubytalk.org/u/David_A_Black3)\ **Post date:** [26 July 2005 00:21 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/7 "2005-07-26T00:21:45Z")
Hi -- > Thanks, rcoder! > > But, what bothers me is the following case. > > class Foo >   def foo >     puts "foo" >   end > end > > Foo.new.send(:foo) > > In this case, :foo is not just a string-like thing. > It seems more like the one in the quoted text. > > What do you think? The :foo in send(:foo) is just a symbol (instance of Symbol :-). It has no special status beyond that. It happens to match the name of a method, but the symbol object has no relation to that method. send is defined so that it can take a symbol or a string; you could also do:    Foo.new.send("foo") which can be handy when you need to do string interpolation to get the name of the method. David > **···** > > On Tue, 26 Jul 2005, Sam Kong wrote: > > -- > David A. Black > dblack@wobblini.net ---
**Author:** ![Daniel\_Amelang](https://avatars.discourse-cdn.com/v4/letter/d/d9b06d/32.png) [@Daniel\_Amelang](https://rubytalk.org/u/Daniel_Amelang)\ **Post date:** [26 July 2005 00:25 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/8 "2005-07-26T00:25:41Z")
> In this case, :foo is not just a string-like thing. > It seems more like the one in the quoted text. In this case, ruby is using an instance of the Symbol class as the search criterion for finding the method. The 'symbol' in the sense of the compiler token never comes into play, because the compiler isn't involved at run time (barring an 'eval' call). The compiler 'symbols' have already been translated into their ruby internal representations (ok, I used broad strokes here, bear with me). Send() just uses the :foo symbol to search the ruby internals for a method with the name 'foo'. BTW, you could have used 'foo' instead of :foo. Dan ---
**Author:** ![Dave\_Burt2](https://yyz1.discourse-cdn.com/flex029/user_avatar/rubytalk.org/dave_burt2/32/2036_2.png) [@Dave\_Burt2](https://rubytalk.org/u/Dave_Burt2)\ **Post date:** [26 July 2005 14:10 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/9 "2005-07-26T14:10:59Z")
Sam Kong asked: > One more think to clear up. > > f.send(:foo) #\<- is :foo a symbol like an instance of Symbol or just a > generic symbol? > If :foo is not an instance of Symbol, then ':' is used for 2 kinds of > things in Ruby, right? :foo is an instance of Symbol % irb irb(main):001:0\> :foo.is\_a? Symbol =\> true The colon (🙂 prefix is Ruby for a literal Symbol, just like surrounding something in quotes (" or ') gives a String, or slashes (/) gives a Regexp. You can of course assign it to a variable like any other object:   x = :foo   f.send(x) A "symbol" in context of the parser, like from your Pickaxe quote, has nothing to do with programming Ruby, it's just used to denote a name or identifier. See how the passage you quote starts: "When Ruby sees a name such as a in an expression" - it's just talking about a word in your code that looks like a variable name or a method name. HTH, Dave ---
**Author:** ![Jay\_Levitt1](https://avatars.discourse-cdn.com/v4/letter/j/ba9def/32.png) [@Jay\_Levitt1](https://rubytalk.org/u/Jay_Levitt1)\ **Post date:** [26 July 2005 03:11 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/10 "2005-07-26T03:11:00Z")
In article \, dblack@wobblini.net says... > The :foo in send(:foo) is just a symbol (instance of Symbol :-). It > has no special status beyond that. It happens to match the name of a > method, but the symbol object has no relation to that method. Really? Is that always true - a Ruby symbol is essentially a C enum except that you can't define an int value for it? So that would mean that Rails's use of symbols (e.g. attr\_reader :foo) is just a convention, and Rails uses the symbol-name to go look up an Object with the same name, thus appearing to releate the Symbol to the Object? > **···** > > -- > Jay Levitt | > Wellesley, MA | I feel calm. I feel ready. I can only > Faster: jay at jay dot fm | conclude that's because I don't have a > [http://www.jay.fm](http://www.jay.fm) | full grasp of the situation. - Mark Adler ---
**Author:** ![Sam\_Kong](https://avatars.discourse-cdn.com/v4/letter/s/ad7895/32.png) [@Sam\_Kong](https://rubytalk.org/u/Sam_Kong)\ **Post date:** [26 July 2005 15:36 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/11 "2005-07-26T15:36:23Z")
Thanks, Dave! Dave Burt wrote: > The colon (🙂 prefix is Ruby for a literal Symbol, just like surrounding > something in quotes (" or ') gives a String, or slashes (/) gives a Regexp. May I think that symbols exist in Ruby becuase Ruby's strings are not immutable? Python, Java, and C# don't have symbols as far as I know. Is it because their strings are immutable? Thanks. Sam ---
**Author:** ![James\_Edward\_Gray\_II](https://avatars.discourse-cdn.com/v4/letter/j/ea5d25/32.png) [@James\_Edward\_Gray\_II](https://rubytalk.org/u/James_Edward_Gray_II)\ **Post date:** [26 July 2005 03:24 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/12 "2005-07-26T03:24:46Z")
Just to be clear, attr\_reader :method\_name is pure Ruby. It's not a Rails-ism. James Edward Gray II > **···** > > On Jul 25, 2005, at 10:11 PM, Jay Levitt wrote: > > > So that would mean that Rails's use of symbols (e.g. attr\_reader :foo) ---
**Author:** ![Martin\_DeMello1](https://avatars.discourse-cdn.com/v4/letter/m/3be4f8/32.png) [@Martin\_DeMello1](https://rubytalk.org/u/Martin_DeMello1)\ **Post date:** [26 July 2005 05:15 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/13 "2005-07-26T05:15:59Z")
> In article \, > dblack@wobblini.net says... > \> The :foo in send(:foo) is just a symbol (instance of Symbol :-). It > \> has no special status beyond that. It happens to match the name of a > \> method, but the symbol object has no relation to that method. > > Really? Is that always true - a Ruby symbol is essentially a C enum > except that you can't define an int value for it? Sort of, though they're closer to lisp atoms - immutable strings stored in a special lookup table. They are convertible to/from strings using String#to\_sym and Symbol#to\_s. They do respond to object equality, if that's what you meant - a = 'hello'; b = 'hello'; c = a.to\_sym; d = b.to\_sym p [a, b, c, d].map {|i| i.object\_id} #=\> c and d are the same object > So that would mean that Rails's use of symbols (e.g. attr\_reader :foo) > is just a convention, and Rails uses the symbol-name to go look up an > Object with the same name, thus appearing to releate the Symbol to the > Object? It's a common ruby convention, but yes, attr\_reader etc. are just methods that take Symbol arguments, and could have been written to take String args instead. martin > **···** > > Jay Levitt \ wrote: ---
**Author:** ![Austin\_Ziegler5](https://yyz1.discourse-cdn.com/flex029/user_avatar/rubytalk.org/austin_ziegler5/32/1985_2.png) [@Austin\_Ziegler5](https://rubytalk.org/u/Austin_Ziegler5)\ **Post date:** [26 July 2005 16:33 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/14 "2005-07-26T16:33:02Z")
You may, but you might not be right. IMO, any comparison of Symbol to something in Python, Java, and C# is (at best) misguided. Strings in Ruby are (by default) mutable, but can be made immutable by freezing them:     irb(main):001:0\> a = "foo"     =\> "foo"     irb(main):002:0\> a \<\< "bar"     =\> "foobar"     irb(main):003:0\> a.freeze     =\> "foobar"     irb(main):004:0\> a \<\< "baz"     TypeError: can't modify frozen string             from (irb):4:in `\<\<'             from (irb):4 IIRC, this is what Hash does when it gets strings as keys:     irb(main):005:0\> a = Hash[\*%w(a b c d)]     =\> {"a"=\>"b", "c"=\>"d"}     irb(main):006:0\> a.keys.each { |k| puts "#{k} frozen? #{k.frozen?}" }     a frozen? true     c frozen? true     =\> ["a", "c"] Symbols are immutable, yes, but their primary feature is that they are constant objects and strings aren't:     irb(main):016:0\> %w(a a a).map {|el| el.freeze.\_\_id\_\_ }     =\> [22676608, 22676596, 22676584]     irb(main):017:0\> %w(a a a).map {|el| el.to\_sym.\_\_id\_\_ }     =\> [3086606, 3086606, 3086606] The comparison of a symbol to a symbol is always going to be computationally cheaper than the comparison of a string to a string. -austin > **···** > > On 7/26/05, Sam Kong \ wrote: > > > Thanks, Dave! > > > > Dave Burt wrote: > > > > > The colon (🙂 prefix is Ruby for a literal Symbol, just like > > > surrounding something in quotes (" or ') gives a String, or > > > slashes (/) gives a Regexp. > > > > May I think that symbols exist in Ruby becuase Ruby's strings are > > not immutable? Python, Java, and C# don't have symbols as far as I > > know. Is it because their strings are immutable? > > -- > Austin Ziegler \* halostatue@gmail.com >                \* Alternate: austin@halostatue.ca ---
**Author:** ![Jim\_Weirich1](https://avatars.discourse-cdn.com/v4/letter/j/73ab20/32.png) [@Jim\_Weirich1](https://rubytalk.org/u/Jim_Weirich1)\ **Post date:** [26 July 2005 16:57 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/15 "2005-07-26T16:57:21Z")
Not really. Strings are used because of their content, immutable or not. Symbols are used because they uniquely define a single object. If you know lisp, then we can say that Ruby symbols are like Lisp atoms. If you don't know Lisp, then learn it first, then we can say that Ruby symbols are like Lisp atoms. 😉 > **···** > > On Tuesday 26 July 2005 11:36 am, Sam Kong wrote: > > > May I think that symbols exist in Ruby becuase Ruby's strings are not > > immutable? > > Python, Java, and C# don't have symbols as far as I know. > > Is it because their strings are immutable? > > -- > -- Jim Weirich jim@weirichhouse.org [http://onestepback.org](http://onestepback.org) > ----------------------------------------------------------------- > "Beware of bugs in the above code; I have only proved it correct, > not tried it." -- Donald Knuth (in a memo to Peter van Emde Boas) ---
**Author:** ![Jay\_Levitt1](https://avatars.discourse-cdn.com/v4/letter/j/ba9def/32.png) [@Jay\_Levitt1](https://rubytalk.org/u/Jay_Levitt1)\ **Post date:** [26 July 2005 06:05 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/16 "2005-07-26T06:05:59Z")
In article \, martindemello@yahoo.com says... > \> So that would mean that Rails's use of symbols (e.g. attr\_reader :foo) > \> is just a convention, and Rails uses the symbol-name to go look up an > \> Object with the same name, thus appearing to releate the Symbol to the > \> Object? > > It's a common ruby convention, but yes, attr\_reader etc. are just > methods that take Symbol arguments, and could have been written to take > String args instead. Thanks. I had always assumed that a symbol :foo was somehow a reference to the var/method/whatever called foo. > **···** > > -- > Jay Levitt | > Wellesley, MA | I feel calm. I feel ready. I can only > Faster: jay at jay dot fm | conclude that's because I don't have a > [http://www.jay.fm](http://www.jay.fm) | full grasp of the situation. - Mark Adler ---
**Author:** ![Daniel\_Brockman](https://avatars.discourse-cdn.com/v4/letter/d/ed8c4c/32.png) [@Daniel\_Brockman](https://rubytalk.org/u/Daniel_Brockman)\ **Post date:** [26 July 2005 08:34 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/17 "2005-07-26T08:34:25Z")
Martin DeMello \ writes: > > So that would mean that Rails's use of symbols > > (e.g. attr\_reader :foo) is just a convention, and Rails > > uses the symbol-name to go look up an Object with the > > same name, thus appearing to releate the Symbol to > > the Object? > > It's a common ruby convention, but yes, attr\_reader > etc. are just methods that take Symbol arguments, and > could have been written to take String args instead. In fact, they do take string arguments.    class Foo      attr\_accessor "bar"    end    foo = Foo.new    foo.bar = 123    foo.bar #=\> 123 > **···** > > -- > Daniel Brockman \ > >     So really, we all have to ask ourselves: >     Am I waiting for RMS to do this? --TTN. ---
**Author:** ![Sam\_Kong](https://avatars.discourse-cdn.com/v4/letter/s/ad7895/32.png) [@Sam\_Kong](https://rubytalk.org/u/Sam_Kong)\ **Post date:** [26 July 2005 17:55 UTC](https://rubytalk.org/t/trying-to-understand-symbols/19741/18 "2005-07-26T17:55:59Z")
Hi, Jim! Jim Weirich wrote: > **···** > > > On Tuesday 26 July 2005 11:36 am, Sam Kong wrote: > > \> May I think that symbols exist in Ruby becuase Ruby's strings are not > > \> immutable? > > \> Python, Java, and C# don't have symbols as far as I know. > > \> Is it because their strings are immutable? > > > > Not really. Strings are used because of their content, immutable or not. > > Symbols are used because they uniquely define a single object. > > > > If you know lisp, then we can say that Ruby symbols are like Lisp atoms. If > > you don't know Lisp, then learn it first, then we can say that Ruby symbols > > are like Lisp atoms. 😉 > > Yeah. I've been reading 'Hackers and Painters' written by Paul Graham > who thinks Lisp is the best language. > I will check Lisp out some day. > Thanks. > > Sam