Tout est objet (vraiment tout) Everything is an object (truly everything)

Demande sa classe à n'importe quoi. Il répondra.Ask anything for its class. It will answer.

Au numéro précédent, tout appel était un message à un receveur. Restait une question : qui peut recevoir un message ? La réponse de Ruby est radicale — tout. Le nombre 42, la chaîne vide, nil, true : aucun n'est une « valeur primitive » à part. Tous répondent à .class, donc tous sont des objets. Sans exception.Last issue, every call was a message to a receiver. One question remained: who can receive a message? Ruby's answer is radical — everything. The number 42, the empty string, nil, true: none is a separate 'primitive value'. They all answer .class, so they are all objects. No exceptions.

42.class        # => Integer
3.14.class      # => Float
"hi".class      # => String
:sym.class      # => Symbol
nil.class       # => NilClass
true.class      # => TrueClass
(1..5).class    # => Range
# pas une seule exception : tout répond à .class

Ailleurs, int et null sont à part. Ici, rien ne l'est.Elsewhere, int and null are set apart. Here, nothing is.

Dans un langage statique, on apprend très tôt une frontière : d'un côté les objets, de l'autre les primitives (int, boolean, null) qui n'ont pas de méthodes — et les classes, qui ne sont pas des valeurs qu'on balade. Ruby efface la frontière entière. Le nombre a des méthodes, nil a une classe, et une classe est une valeur qu'on assigne et qu'on passe en argument.In a static language, you learn a border early: objects on one side, primitives (int, boolean, null) with no methods on the other — and classes, which aren't values you carry around. Ruby erases the entire border. The number has methods, nil has a class, and a class is a value you assign and pass as an argument.

// Java : des primitives qui ne sont PAS des objets
int n = 42;
n.toString();        // erreur de compilation : int n'a pas de méthodes
null.getClass();     // ne compile même pas : null ne se déréférence pas

// et une classe n'est pas une valeur ordinaire :
Class c = Integer;   // non : Integer n'est pas une expression
String.class         // un objet Class à part, réservé à la réflexion

Deux mondes coexistent : les objets, qui ont des méthodes, et les primitives, qui n'en ont pas. null n'est pas un objet : l'interroger plante. Et une classe est un citoyen de seconde zone, réservé à la réflexion.Two worlds coexist: objects, which have methods, and primitives, which don't. null isn't an object: querying it crashes. And a class is a second-class citizen, confined to reflection.

Deux axes, jamais confondus : « est une instance de » et « hérite de ».Two axes, never confused: "is an instance of" and "inherits from".

Si une classe est un objet, elle a forcément, elle aussi, une classe. C'est Class. Et Class est une instance de Class — la tour se referme sur elle-même. Le piège, ici, est de mélanger deux relations distinctes : « 42 est une instance d'Integer » (l'axe de la classe) n'est pas « Integer hérite de Numeric » (l'axe de l'héritage). Démêler les deux, c'est tenir tout le métamodèle.If a class is an object, it too must have a class. That's Class. And Class is an instance of Class — the tower closes on itself. The trap here is mixing two distinct relations: '42 is an instance of Integer' (the class axis) is not 'Integer inherits from Numeric' (the inheritance axis). Untangle the two and you hold the whole metamodel.

42.class             # => Integer    — l'objet 42 est une instance d'Integer
Integer.class        # => Class      — Integer est une instance de Class
Class.class          # => Class      — et Class est une instance… de Class (ça boucle)

Integer.superclass   # => Numeric    — l'héritage, lui, est un AUTRE axe
Numeric.superclass   # => Object
Object.superclass    # => BasicObject
BasicObject.superclass # => nil      — la racine de tout

# Une classe est un objet : on peut donc en FABRIQUER une à l'exécution
Point = Class.new do
  def initialize(x, y) = (@x, @y = x, y)
  def to_s = "(#{@x}, #{@y})"
end

Point.new(1, 2).to_s   # => "(1, 2)"
# class Point ... end fait le même travail que ce Class.new — à deux
# nuances près : class ouvre une portée étanche (pas de closure), et
# rouvre la classe si elle existe déjà

class Point ... end n'est pas une construction magique du langage : c'est du sucre par-dessus Class.new, qui retourne un objet qu'on range dans la constante Point. Définir une classe, c'est créer un objet et lui donner un nom.class Point ... end is no magic language construct: it's sugar over Class.new, which returns an object you store in the constant Point. Defining a class is creating an object and giving it a name.

« Tout est objet » donne envie de comparer des classes. N'en fais rien."Everything is an object" tempts you to compare classes. Don't.

Le revers de la médaille : une fois qu'on a compris qu'une classe est une valeur ordinaire, on se met à brancher dessus — if value.class == String. C'est ramener à Ruby le réflexe d'un langage à types : on se ferme aux sous-classes, on oublie tous les types qu'on n'a pas énumérés, et on tourne le dos à la seule chose qui compte — est-ce que l'objet répond au message ?The flip side: once you grasp that a class is an ordinary value, you start branching on it — if value.class == String. That's importing a typed-language reflex into Ruby: you shut out subclasses, forget every type you didn't enumerate, and turn your back on the only thing that matters — does the object respond to the message?

# Le réflexe : puisque la classe est une valeur, je compare des classes
def render(value)
  if value.class == String
    value
  elsif value.class == Integer
    value.to_s
  end
end

render("hi")          # => "hi"
render(42)            # => "42"
render(:sym)          # => nil  — Symbol n'était pas prévu, on retombe dans le vide
render(3.14)          # => nil  — Float non plus

# pire : == compare la classe EXACTE
class Money < String; end
render(Money.new("5")) # => nil  — une sous-classe de String est rejetée !

# Le correctif : n'interroge pas la classe — envoie le message
def render(value) = value.to_s

render("hi")          # => "hi"
render(42)            # => "42"
render(:sym)          # => "sym"
render(Money.new("5")) # => "5"   — la sous-classe répond, donc elle passe
# Tout objet répond à to_s (Vol 1 № 1). On fait confiance au message.