Using symbols to access instance variables?

Question

Apparently, Ruby can make a code block returning an instance variable's value with a symbol. Consider:

class Person
    attr_accessor :fn
end

def give(n,&b)
    i=0
    while(i<n)
       aa = Person.new
       aa.fn = "name #{i}"
       i=i+1
       puts b.call(aa)
    end
end

Now, both give(5, &:fn) and give(5) {|x| x.fn} give

name 0
name 1
name 2
name 3
name 4
=> nil

But what does &:fn really mean? I know the ampersand can convert a Proc to a block such as

bb = Proc.new {|x| x.fn}
give(5, &bb)

So what does the symbol :fn mean? Where can I see a documentation of its use like this? Can we use a symbol to access the instance variable, like say person:new or person[:new]?

`person[:new]` would be used for accessing a hash where the key is a symbol — Kassym Dorsel, Jul 17 '12 at 19:32
@KassymDorsel, thanks. I know the case for hashes, but here it is an object of a class, and the symbol in '&:fn` accesses the instance variable. — highBandWidth, Jul 17 '12 at 19:37
ampersand will convert object to `Proc` actually, and `:fn` means just symbol, `&:fn` is equivalent to `&(:fn.to_proc)` — Victor Moroz, Jul 17 '12 at 19:37
@VictorMoroz, you mean `&:fn` is equivalent to `:fn.to_proc`? — highBandWidth, Jul 17 '12 at 19:38
you can pass lambda to your function like this `give(5, &lambda{ |x| x.fn })`, ampersand is a part of Ruby syntax for passing `Proc` object to a method (or any other object if it has `to_proc` method). — Victor Moroz, Jul 17 '12 at 19:41
http://pragdave.pragprog.com/pragdave/2005/11/symbolto_proc.html — Kassym Dorsel, Jul 17 '12 at 19:43
Yes. See http://stackoverflow.com/questions/1217088/what-does-mapname-mean-in-ruby — Mark Thomas, Jul 17 '12 at 19:46
@highBandWidth "and the symbol in '&:fn` accesses the instance variable. " No, no, it calls the `fn` method. — steenslag, Jul 17 '12 at 19:50

Linuxios · Accepted Answer · 2012-07-17T20:07:39.900

Simple. The statment

attr_accessor :fn

Doesn't define some sort of special instance variable thing. It declares two methods of (approximately) this form:

def fn
  @fn
end
def fn=(v)
  @fn=v
end

The Ruby "syntax" &:fn is a symbol that the operator & tries to convert to a proc. And, guess what? Symbol implements to_proc. Guess that that looks like:

def to_proc
  Proc.new {|obj| obj.__send__(self)}
end

That captures self, which is the symbol :fn, which, on invocation, tells obj to execute the method fn, which returns the value of the instance variable.

EDIT: Answering the second part of the question, no and yes. With the syntax you say, no. But you can call a method from a symbol with BasicObject#__send__ and you can do the same for not attr_accessor instance variables with Object#instance_variable_get.

Using symbols to access instance variables?

1 Answers1