Class, Module, Object

reload!

Reloading...
=> true

puts Class < Module

true
=> nil

puts Module < Class

false
=> nil

puts Module < Object

true
=> nil

puts Object < Module

false
=> nil

Object.parent

=> Object

The above indicates that the Class object instance inherits from the
Module object instance and the Module object instance inherits from
Object. And Object doesn't inherit from anything.

So why do these return true:

Module.is_a?(Class)

=> true

Object.is_a?(Module)

=> true

Class, Module and Object are instances of the Class class.

Class.class
=> Class

Module.class
=> Class

Object.class
=> Class

Class inherits from Module, which inherits from Object

Class.superclass
=> Module

Module.superclass
=> Object

So, every instance of the Class class is_a?(Class) and is_a?(Module) and is_a?(Object).

Module.is_a?(Class)

Module inherits from Object, Object is an instance of Class.

Object.is_a?(Module)

Object is an instance of Class, Class inherits from Module.

Yes, Object, Class, and Module are more than just constants. Object,
Class, and Module are instances of Class class:

1.9.3p0 :031 > Class.class
=> Class
1.9.3p0 :032 > Module.class
=> Class
1.9.3p0 :033 > Object.class
=> Class

Since Object, Class, and Module are instances of Class class, they
don't have access to Class's singleton methods, but rather they have
access to Class's instance methods:

1.9.3p0 :052 > class Class
1.9.3p0 :053?> def Class.abc
1.9.3p0 :054?> puts 'abc'
1.9.3p0 :055?> end
1.9.3p0 :056?> end
=> nil

1.9.3p0 :076 > Module.abc
NoMethodError: undefined method `abc' for Module:Class

1.9.3p0 :077 > Object.abc
NoMethodError: undefined method `abc' for Object:Class

However, since we defined the singleton method on Class, it will work
on a Class invocation:

1.9.3p0 :078 > Class.abc
abc
=> nil

But instance methods work:

1.9.3p0 :012 > Class.instance_methods(false)
=>
[:allocate, :new, :superclass, :cattr_reader, :cattr_writer, :cattr_accessor,
…]

1.9.3p0 :015 > Object.cattr_writer
=> []
1.9.3p0 :017 > Module.cattr_reader
=> []
1.9.3p0 :018 > Class.cattr_writer
=> []

This here is an indication that Object and Module are instances of
Class but DO NOT inherit from Class. Let's check that out with the
superclass call:

1.9.3p0 :079 > Class.superclass
=> Module
1.9.3p0 :080 > Module.superclass
=> Object
1.9.3p0 :081 > Object.superclass
=> BasicObject
1.9.3p0 :082 > BasicObect.superclass
=> nil

Thus, Class inherits from Module, and Module in turn inherits from
Object, which in turn inherits from BasicObject in ruby 1.9. We can
test that out by seeing if we define a singleton method on Module,
then Class should be able to invoke it, since there is inheritance
between them.

1.9.3p0 :067 > class Module
1.9.3p0 :068?> def Module.qqqw
1.9.3p0 :069?> puts 'qqqw'
1.9.3p0 :070?> end
1.9.3p0 :071?> end
=> nil
1.9.3p0 :072 > Module.singleton_methods(false)
=>
[:nesting, :constants, :attr_internal_naming_format, :attr_internal_naming_format=, :qqqw]
1.9.3p0 :073 > Class.qqqw
qqqw
=> nil
1.9.3p0 :074 > Object.qqqw
NoMethodError: undefined method `qqqw' for Object:Class

1.9.3p0 :084 > class Object
1.9.3p0 :085?> def Object.ttyy
1.9.3p0 :086?> puts 'ttyy'
1.9.3p0 :087?> end
1.9.3p0 :088?> end
=> nil
1.9.3p0 :089 > Module.ttyy
ttyy
=> nil
1.9.3p0 :090 > Class.ttyy
ttyy
=> nil

This shows the role of inheritance. We defined a singleton method on
Object, and thus since Module inherits from Object, it had access to
it, and so did Class, since Class inherits from Module, which in turn
inherits from Object.

Now that's the metaclass (eigenclass) inheritance relationship (the
fact that the eighenclass of Class inherits the singleton methods of
the eighenclass of Module which in turn inherits the singleton methods
of eigenclass of Object). If the inheritance relationship did not
exist as it does, then we wouldnt be able to call singleton methods of
Module on Class, for example.

Furthermore, we have a circular relationship. Since Class is an
instance of Class, Module is an instance of Class, and Object is an
instance of Class, they all have access to instance methods of Class,
as already stated. What's more interesting is the circular
relationship that has been created via the combination of
instantiation and inheritance. If Object is an instance of Class, and
Class inherits from Module, then that means Class is an instance of
Module, and so since Object is an instance of Class, it itself is an
instance of Module. Hence, we can access the INSTANCE METHODS of any
of these classes via the other Class.

1.9.3p0 :094 > Class.is_a?(Module)
=> true
1.9.3p0 :095 > Module.is_a?(Class)
=> true
1.9.3p0 :096 > Object.is_a?(Module)
=> true
1.9.3p0 :097 > Object.is_a?(Class)
=> true

Now lets access an instance method of Module on Object:

1.9.3p0 :098 > Module.instance_methods(false)
=>
[:freeze, :===, :==, :<=>, :<, :<=, :>, :>=, :to_s, :included_modules, :include?, :name, :ancestors, :instance_methods, :public_instance_methods, :protected_instance_methods, :private_instance_methods, :constants, :const_get, :const_set, :const_defined?, :class_variables, :remove_class_variable, :class_variable_get, :class_variable_set, :class_variable_defined?, :public_constant, :private_constant, :module_exec, :class_exec, :module_eval, :class_eval, :method_defined?, :public_method_defined?, :private_method_defined?, :protected_method_defined?, :public_class_method, :private_class_method, :autoload, :autoload?, :instance_method, :public_instance_method, :psych_yaml_as, :yaml_as, :deprecate, :alias_method_chain, :alias_attribute, :mattr_reader, :mattr_writer, :mattr_accessor, :remove_possible_method, :redefine_method, :delegate, :instance_method_names, :method_names, :attr_internal_reader, :attr_internal_writer, :attr_internal_accessor, :attr_internal, :anonymous?, :duplicable?, :reachable?, :parent_name, :parent, :parents, :local_constants, :local_constant_names, :attr_accessor_with_default, :synchronize, :pretty_print_cycle, :pretty_print, :xyz]
1.9.3p0 :099 > Object.included_modules
=> [PP::ObjectMixin, ActiveSupport::Dependencies::Loadable,
JSON::Ext::Generator::GeneratorMethods::Object, Kernel]

And there you go, it worked.

I want to fix a typo. I said:

Since Object, Class, and Module are instances of Class class, they
don't have access to Class's singleton methods, but rather they have
access to Class's instance methods:

I meant to say:

Object and Module do not inherit from Class and so they
don't have access to Class's singleton methods, but since Object,
Class, and Module are instances of Class class, they all have
access to Class's instance methods: