Local variables in class definitions / scope

Question

I was under the impression that class definitions in Ruby can be reopened:

class C
  def x
    puts 'x'
  end
end

class C
  def y
    puts 'y'
  end
end

This works as expected and y is added to the original class definition.

I'm confused as to why the following code doesn't work as expected:

class D
  x = 12
end

class D
  puts x
end

This will result in a NameError exception. Why is there a new local scope started when a class is reopened? This seems a little bit counterintuitive. Is there any way to continue the previous local scope when a class is extended?

Answer 1

Local variables are not associated with an object, they are associated with a scope.

Local variables are lexically scoped. What you are trying to do is no more valid than:

def foo
  x = :hack if false  # Ensure that x is a local variable
  p x if $set         # Won't be called the first time through
  $set = x = 42       # Set the local variable and a global flag
  p :done
end

foo                   #=> :done 

foo                   #=> nil (x does not have the value from before)
                      #=> done

In the above it's the same method, on the same object, that's being executed both times. The self is unchanged. However, the local variables are cleared out between invocations.

Re-opening the class is like invoking a method again: you are in the same self scope, but you are starting a new local context. When you close the class D block with end, your local variables are discarded (unless they were closed over).

Answer 2

In ruby, local variables accessible only in scope that they are defined. However, the class keywords cause an entirely new scope.

class D
  # One scope
  x = 12
end

class D
  # Another scope
  puts x
end

So, you can't get access to local variable that defined in first class section, because when you leave first scope, local variable inside it is destroyed and memory is freed by garbage collection.

This is also true for the def, for example.