eigenclass

I understand the regular method lookup path i.e. class, superclass/module, all the way up to BasicObject . I thought it was true for singleton version of the chain also but doesn't seem the case when you mixin a module in the meta-chain. I'd appreciate if someone can explain why in the following example Automobile module's banner method is called instead of its singleton version when I have included this module in Vehicle's eigenclass. module Automobile def banner "I am a regular method of Automobile" end class << self def banner "I am a singleton method of Automobile" end end end class

According to Dave Thomas in his talk about the Ruby Object Model , there are no "class methods" in Ruby. There is only difference between whether the receiver of the method is a "class object" or an "instance object". class Dave def InstaceMethod ### will be stored in the current class (Dave) puts "Hi" end class << self ### Creates an eigenclass, if not created before def say_hello puts "Hello" end end end By default, ancestors method doesn't show the metaclass: class Dave class << self def metaclass ### A way to show the hidden eigenclass class << self; self; end end end end p Dave.ancestors

I was trying to limit the instantiation of a class to just a single one(without using singleton) but i couldn't. I tried with class variables (@@) but without luck. I googled it and came across this: class A @count = 0 class << self attr_accessor :count end def initialize val @a = val self.class.count += 1 end end a=A.new 42 b=A.new 43 I searched for the 'class << self ' explanation hoping to find a better(or just a more simple and clean) but againt, no luck. Finally, after some tests i concluded that 'class << self ' is just a block wrapper where you can define class methods. So, is this the

I've missed the memo somewhere, and I hope you'll explain this to me. Why is the eigenclass of an object different from self.class ? class Foo def initialize(symbol) eigenclass = class << self self end eigenclass.class_eval do attr_accessor symbol end end end My train of logic that equates the eigenclass with class.self is rather simple: class << self is a way of declaring class methods, rather than instance methods. It's a shortcut to def Foo.bar . So within the reference to the class object, returning self should be identical to self.class . This is because class << self would set self to