Appearance of singleton class

Question

There appears to be a contrast between singleton classes of nil, false, true and that of an instance of a custom made class.

i) The singleton class of nil, false, and true are referred to by their assigned constant names:

nil.singleton_class #=> NilClass
false.singleton_class #=> FalseClass
true.singleton_class #=> TrueClass

ii) The singleton class of nil, false, and true appear on ancestor lists:

nil.class.ancestors #=> [NilClass, Object, Kernel, BasicObject]
false.class.ancestors #=> [FalseClass, Object, Kernel, BasicObject]
true.class.ancestors #=> [TrueClass, Object, Kernel, BasicObject]

For the singleton class named AClass of an instance a of a custom class A,

class A; end
a = A.new
AClass = a.singleton_class

i) AClass is not referred to by its assigned constant name:

a.singleton_class #=> #<Class:#<A:0x00007fda832a7eb0>>

ii) AClass does not appear on the ancestor list:

a.class.ancestors #=> [A, Object, Kernel, BasicObject]

Is this the expected behavior? What divides nil, false, true on the one hand and a on the other? What does this specification follow from?

Answer 1

Not sure if this helps, but from the docs for singleton_class:

If obj is nil, true, or false, it returns NilClass, TrueClass, or FalseClass, respectively.

So singleton_class has a special behaviour for nil, true and false instead of the standard behaviour of returning the objects's singleton class.

Answer 2

1. nil, false, true objects

i) The singleton class of nil, false, and true are referred to by their assigned constant names:

This is not correct. The singleton_class method of nil, true and false does not return their singleton classes since they don't exist. Instead, it returns their actual classes. The reason why those objects don't have singleton classes is obvious and is well described in the @zeitnot's answer.

This behaviour is expected and is documented here https://ruby-doc.com/core/Object.html#method-i-singleton_class

ii) The singleton class of nil, false, and true appear on ancestor lists

This is not correct too. Since those objects don't have singleton classes, what you see in the ancestors list is their actual classes. But even if they had singleton classes, you wouldn't get them by that way (continue reading to know why)

2. an instance a of a custom class A

i) AClass is not referred to by its assigned constant name:

AClass = a.singleton_class

This code makes AClass refer to a.singleton_class. But it is one-direction relation (from AClass to a.singleton_class). It doesn't make a.singleton_class refer to and return AClass as you are expecting.

ii) AClass does not appear on the ancestor list:

To get an ancestors list including the singleton class execute a.singleton_class.ancestors instead of a.class.ancestors.

a.singleton_class.ancestors #=> [#<Class:#<A:0x000000000191dba0>>, A, Object, Kernel, BasicObject]

The ancestors method only looks up the hierarchy:

class A; end
class B < A; end
class C < B; end

A.ancestors # => [A, ...]
B.ancestors # => [B, A, ...]
C.ancestors # => [C, B, A, ...]

Answer 3

A good example often says more than a lot of words:

require 'singleton'

class FooClass
  include Singleton
  alias singleton_class class

  def inspect
    'foo'
  end
end

Now let's have a look at the similarities:

true #=> true
true.class #=> TrueClass
true.singleton_class #=> TrueClass

foo = FooClass.instance # unfortunately the syntax is not exactly the same
foo #=> foo
foo.class #=> FooClass
foo.singleton_class #=> FooClass

This means that true.singleton_class refers to its own class instead of its singleton class. This makes sense, since true is a singleton which makes its own class the singleton class per definition. (Since it is the class of a singleton.)

Answer 4

In ruby, NilClass, FalseClass and TrueClass can have only one instance. So this is why they do not have a singleton_class.

For Example:

a = nil 
def a.foo
  'foo'
end 

b = nil 
b.foo => # foo

As we might see, b responds to foo method and returns foo string even though we defined foo method for variable a. This means these 3 classes can have only one instance. And there is another thing to point out that nil, false and true are variables but pseudo-varibles. They can not be assigned different data structures. In a sense, they are frozen variables.