Why is EVERYTHING an instance of a class in Ruby?

Question

I don’t quite understand something about the Ruby object model. First, ALWAYS an instance of Class in Ruby? All this creates the truth:

 p Object.instance_of?(Class) p Class.instance_of?(Class) p Module.instance_of?(Class) p BasicObject.instance_of?(Class) class Hello; end p Hello.instance_of?(Class) 

I cannot understand how this is possible if Object is a superclass of Class , how can it be both a superclass of Class and an instance of it at the same time (most diagrams on the Ruby object model clearly define this hierarchy)? Which allows for some crazy situation:

 p BasicObject.is_a?(Object) #=> true 

where BasicObject.class is Class and Class.is_a?(Object) .

By the way, using Ruby 2.0.

Answer 1

First, ALWAYS an instance of Class in Ruby?

No, not all of these are Class examples. Only classes are instances of Class .

There are many things that are not instances of Class : strings, for example, are instances of String , not Class . Arrays are instances of Array , integers are instances of Integer , floats are instances of Float , true is an instance of TrueClass , false is an instance of FalseClass , nil is an instance of NilClass , etc.

Each class is an instance of Class , just as each row is an instance of String .

if Object is a superclass of Class , how can it be both a superclass of Class and an instance of it at the same time (in most diagrams on the Ruby object model this hierarchy is clearly indicated)?

Magic.

As in most other languages, there are some basic entities that are supposed to exist. They fall from the sky, materialize from the air, magically appear.

In Ruby, some of these magical things are:

• Object does not have a superclass, but you cannot define a class without a superclass; the implicit direct superclass is always Object . [Note: there may be implementation superclasses of Object , but ultimately there will be one that does not have a superclass.]
• Object is an instance of Class , which is a subclass of Object (which means that, indirectly, Object is an instance of Object itself)
• Class is a subclass of Module , which is an instance of Class
• Class is an instance of Class

None of these things can be explained in Ruby.

BasicObject , Object , Module and Class all have to exist spring at the same time, because they have circular dependencies.

Just because this relationship cannot be expressed in Ruby code does not mean that the Ruby language specification cannot say that it should be so. It is up to the developer to figure out a way to do this. In the end, the Ruby implementation has a level of access to objects that you, as a programmer, do not have.

For example, a Ruby implementation may first create a BasicObject by setting both its superclass pointer and the Class pointer to null .

He then creates an Object by setting the superclass pointer to BasicObject and its Class pointer to null .

He then creates a Module by setting the superclass pointer to Object and its Class pointer to null .

Finally, he creates a Class by setting the superclass pointer to Module and its Class pointer to null .

Now we can rewrite BasicObject 's, Object ' s, Module 'and Class Class pointer to Class , and we are done.

This is easy to do from outside the system; it just looks weird from the inside.

Answer 2

You should notice that:

 p BasicObject.instance_of?(BasicObject) 

outputs false .

That is, the BasicObject expression BasicObject not an instance of BasicObject , it is an instance of something else, that is, a Class object that represents an object that contains (for example) a class, for example new .

For instance:

 p (BasicObject.new()).instance_of?(BasicObject) 

outputs true and

 p (BasicObject.new()).instance_of?(Class) 

outputs false .

Answer 3

All your examples were by definition classes. Classes are also objects. But what you did not do is look at the class instance:

 p Object.new.class p Hello.new.class 

Classes define the shape of an object, and by definition, a class is a class. But when you instantiate the class into an object, the object is a new type. But you can still see that the class of the object itself is a class:

 p Hello.new.class.class