Modules, ou un seul mot pour deux outils Modules, or one word for two tools

Un seul mot, module, pour deux outils différents.One word, module, for two different tools.

Le Vol 5 ouvre la question : d'où un objet tient-il son comportement ? Et la réponse de Ruby commence par le module — un mot qui recouvre deux usages qu'on confond souvent. Premier rôle : ranger. Un module est un espace de noms qui regroupe constantes et classes sous un préfixe, pour éviter les collisions (Billing::Invoice n'est pas Shipping::Invoice). Second rôle : partager. Un module mixé dans une classe par include y injecte ses méthodes, comme un héritage de capacité. Même mot, deux intentions — et tout le volume commence par les distinguer.Vol 5 opens the question: where does an object get its behavior? And Ruby's answer starts with the module — one word covering two uses we often conflate. First role: organizing. A module is a namespace grouping constants and classes under a prefix, to avoid collisions (Billing::Invoice isn't Shipping::Invoice). Second role: sharing. A module mixed into a class via include injects its methods, like an inheritance of capability. Same word, two intentions — and the whole volume begins by telling them apart.

module Billing                 # 1) un ESPACE DE NOMS : il range
  TAX = 0.2
  class Invoice; end           # Billing::Invoice, pas la même qu'ailleurs
end

module Greetable               # 2) un MIXIN : il partage du comportement
  def greet = "Bonjour, #{name}"
end

Billing::TAX                   # => 0.2      on RANGE et on accède via ::
class User
  include Greetable            # on PARTAGE : greet entre dans User
  attr_reader :name
  def initialize(n) = @name = n
end
User.new("Ada").greet          # => "Bonjour, Ada"

Ranger laisse le module dehors ; mixer le fait entrer.Organizing keeps the module outside; mixing pulls it in.

La même définition de module se manipule de deux façons opposées. En espace de noms, le module reste un tiroir extérieur : on y accède par ::, rien n'entre dans aucune classe — c'est de l'organisation pure, qui évite les collisions de noms. En mixin, include fait l'inverse : il insère le module dans la chaîne d'ancêtres de la classe, et ses méthodes deviennent des méthodes d'instance, appelables comme si elles avaient été écrites là. Le premier usage range des noms ; le second greffe du comportement.The same module definition is handled in two opposite ways. As a namespace, the module stays an outer drawer: you reach it via ::, nothing enters any class — pure organization that avoids name collisions. As a mixin, include does the reverse: it inserts the module into the class's ancestor chain, and its methods become instance methods, callable as if written there. The first use files names; the second grafts behavior.

# Le module comme TIROIR : on range, on accède du dehors par ::
module Payments
  CURRENCY = "EUR"
  class Charge
    def initialize(amount) = @amount = amount
  end
  module Gateways          # on peut imbriquer des modules
    class Stripe; end
  end
end

Payments::CURRENCY              # => "EUR"
Payments::Charge.new(10)        # une Charge bien rangée
Payments::Gateways::Stripe.new  # :: descend la hiérarchie de noms

# aucune méthode n'est entrée nulle part : le module reste DEHORS

Payments ne fait que regrouper : ses constantes et classes vivent sous son préfixe, et :: les atteint depuis l'extérieur. Rien n'est injecté nulle part — c'est ce qui permet à deux bibliothèques d'avoir chacune leur Charge sans se marcher dessus. Le module est une adresse, pas une greffe.Payments only groups: its constants and classes live under its prefix, and :: reaches them from outside. Nothing is injected anywhere — that's what lets two libraries each have their own Charge without clashing. The module is an address, not a graft.

include, extend, module_function : où les méthodes atterrissent.include, extend, module_function: where the methods land.

Un même module donne des méthodes à des endroits différents selon le verbe. include les pose en méthodes d'instance : toutes les instances de la classe les gagnent. extend les pose sur un seul objet — et comme une classe est un objet, extend dans un corps de classe en fait des méthodes de classe. module_function, enfin, rend les méthodes appelables directement sur le module, qui devient un porte-fonctions à la Math. Trois verbes, une question : sur quel receveur veux-tu que ces méthodes répondent ?One module gives methods to different places depending on the verb. include lays them down as instance methods: every instance of the class gains them. extend lays them on a single object — and since a class is an object, extend in a class body makes them class methods. module_function, finally, makes the methods callable directly on the module, which becomes a function-holder à la Math. Three verbs, one question: on which receiver do you want these methods to answer?

module Sayable
  def say = "salut de #{self}"
end

class A
  include Sayable     # → méthodes d'INSTANCE
end
A.new.say             # => "salut de #<A>"   sur les instances

class B
  extend Sayable      # → méthodes de CLASSE
end
B.say                 # => "salut de B"      sur la classe elle-même

obj = "x"
obj.extend(Sayable)   # → sur CET objet uniquement
obj.say               # => "salut de x"

module Calc
  module_function       # rend les méthodes suivantes appelables sur le module

  def double(x) = x * 2
  def triple(x) = x * 3
end

Calc.double(4)          # => 8    le module se comporte comme un porte-fonctions
Calc.triple(4)          # => 12   sans avoir à l'inclure ni à l'instancier

Une astuce courante condense deux de ces verbes : extend self dans un module le rend à la fois mixable (include ailleurs) et appelable directement (MonModule.methode). On en reparlera au № 3 du volume ; pour l'instant, retiens la grille — include pour les instances, extend pour un objet, module_function pour le module — et tu sais déjà où chaque méthode va répondre.A common trick condenses two of these verbs: extend self in a module makes it both mixable (include elsewhere) and directly callable (MyModule.method). We'll return to it in the volume's № 3; for now, keep the grid — include for instances, extend for an object, module_function for the module — and you already know where each method will answer.

include pour une simple constante : tout un module dans la classe.include for a single constant: a whole module in the class.

Le contre-exemple du numéro naît exactement de la confusion des deux rôles. On veut une constante rangée dans un module — Math::PI — et, par réflexe, on écrit include Math. Mais include est le verbe du mixin, pas du namespace : il insère Math dans la chaîne d'ancêtres et déverse ses vingt-six fonctions en méthodes (privées) de chaque instance. On a payé une greffe entière pour lire une constante. Le bon geste tenait dans deux caractères : :: accède au tiroir sans rien aspirer. include partage ; pour ranger, on nomme.The issue's counter-example springs precisely from conflating the two roles. You want a constant filed in a module — Math::PI — and, by reflex, you write include Math. But include is the mixin verb, not the namespace one: it inserts Math into the ancestor chain and dumps its twenty-six functions as (private) methods on every instance. You paid for a whole graft to read one constant. The right move was two characters: :: reaches the drawer without pulling anything in. include shares; to organize, you name.

# On voulait juste PI… alors on inclut tout Math
class Circle
  include Math               # mixin : aspire TOUT le module
  def area(r) = PI * r ** 2  # certes, PI est là maintenant
end

Circle.ancestors
# => [Circle, Math, Object, ...]   ← Math coincé dans la chaîne
Circle.private_instance_methods.grep(/sqrt|sin|hypot/)
# => [:sqrt, :sin, :hypot, ...]   ← 26 méthodes injectées dans CHAQUE Circle
#    pour une seule constante : on a confondu « ranger » et « partager »

# On accède au namespace par ::, sans rien aspirer
class Circle
  def area(r) = Math::PI * r ** 2   # :: vise la constante, point
end

Circle.ancestors
# => [Circle, Object, ...]          ← Math n'est PAS dans la chaîne
Circle.private_instance_methods.grep(/sqrt|sin/)
# => []                              ← zéro pollution

Math.sqrt(9)   # et si on veut les fonctions : on les appelle sur Math