I’ll try to sum it up in a more concise way :

When you are in a module and define a “module method” (e.g. def self.my_module_method), the execution context is the module itself (which is an object as well). When you are in a module and define an “instance method” (e.g. def my_instance_method), the execution context is the class instance that includes the module. This is like you had pasted all the instance methods from the module in your class. This is why we can say that the instance variables are in the class

the first form:

module SomeModule
def self.talk
@x = ..

since module themselves are object, classes that get this module included have no access to it’s instance method, thus this @x is visible only in the module itself.

on the other hand, instance methods defined in modules becomes instance methods of object with which the class has got the module mixed in, thus this instance variable is.. well instance variable in
per-object basis,right Frank??

sorry for my pool english..

freenight,this is a very good question.

Instance variables in modules can belong to either :

1: The module
2: The client class

If you need a variable that will exist at “module level” you will do it this way

module SomeModule
def self.set_instance_variable
#this method is not accessible for a client class
#in this case the term “instance” refers to the module itself
@x = “bla bla bla”
end

def self.get_instance_variable
@x
end
end

SomeModule.set_instance_variable
SomeModule.get_instance_variable #output : bla bla bla

Conclusion : When you use instance variables inside “module level” methods, these variables are only available in the module itself.

Now, if you want to use instance variables where an “instance” refers to the client class instance and NOT the module itself, you have to proceed this way.

module SomeModule
def set_instance_variable
#only difference is that I removed the ’self.’ part in the method definition. It means that this
#method will reside into the client class instance and NOT in the module itself
@x = “bla bla bla”
end

def get_instance_variable
@x
end
end

class SomeClass
include SomeModule
end

x=SomeClass.new

x.set_instance_variable
x.get_instance_variable #output is “bla bla bla”