extend & composition, ou être plutôt que savoir faire extend & composition, or being versus knowing how

include vise les instances ; extend vise un objet.include targets instances; extend targets one object.

Le № 2 a inséré des modules dans la chaîne d'une classe, pour ses instances. extend déplace la greffe d'un cran : il mixe un module sur un seul objet. Et comme une classe est elle-même un objet (Vol 1), extend dans un corps de classe produit des méthodes de classe — l'idiome le plus courant. Sur un objet ordinaire, c'est un décorateur ponctuel : on équipe cette instance-là, et elle seule. Même module, même mécanique de chaîne, mais appliquée à l'objet plutôt qu'au moule qui le fabrique.№ 2 inserted modules into a class's chain, for its instances. extend moves the graft one notch: it mixes a module onto a single object. And since a class is itself an object (Vol 1), extend in a class body produces class methods — the most common idiom. On an ordinary object, it's a one-off decorator: you equip that instance, and it alone. Same module, same chain mechanics, but applied to the object rather than the mold that makes it.

module Helpers
  def help = "j'aide #{self}"
end

# extend mixe sur UN objet précis — pas sur toutes les instances
obj = Object.new
obj.extend(Helpers)
obj.help              # => "j'aide #<Object>"   greffé sur CET objet seul

# et comme une classe EST un objet (Vol 1)…
class Widget
  extend Helpers      # …extend dans une classe = méthode de CLASSE
end
Widget.help           # => "j'aide Widget"
Widget.new.respond_to?(:help)   # => false   les instances ne l'ont pas

Un module qui se mixe lui-même, ou qui équipe les deux côtés.A module that mixes itself, or equips both sides.

Deux idiomes naissent de extend. Le premier, extend self, fait qu'un module s'inclut dans lui-même : ses méthodes deviennent appelables directement (Config.root) tout en restant mixables ailleurs — pratique pour une config ou un sac d'utilitaires à double usage. Le second résout un besoin fréquent : un seul include qui équipe à la fois les instances ET la classe. Le hook included intercepte le mixin et fait un extend ClassMethods au passage. C'est le motif des « concerns » : include d'un côté, methodes d'instance et de classe greffées ensemble.Two idioms grow from extend. The first, extend self, makes a module include itself: its methods become directly callable (Config.root) while staying mixable elsewhere — handy for a config or a dual-use utility bag. The second solves a common need: a single include that equips both the instances AND the class. The included hook intercepts the mixin and does an extend ClassMethods along the way. It's the 'concerns' pattern: include on one side, instance and class methods grafted together.

module Config
  extend self            # le module se mixe LUI-MÊME

  def root = "/app"
  def env  = ENV.fetch("APP_ENV", "dev")
end

Config.root              # => "/app"   appelable directement sur le module
Config.env               # => "dev"

# et comme c'est un module, on peut aussi l'inclure ailleurs :
class Worker
  include Config         # root et env deviennent méthodes d'instance
end
Worker.new.root          # => "/app"

extend self dit : « inclus-moi dans mon propre objet ». Le module devient alors un porte-fonctions appelable (Config.root) — même service que module_function du № 1, mais qui garde les méthodes publiques une fois mixées par include (module_function, lui, les y fait entrer en privé). Un seul module, deux portes d'entrée.extend self says: "include me in my own object". The module then becomes a callable function-holder (Config.root) — same service as № 1's module_function, but keeping the methods public once mixed in via include (module_function brings them in as private). One module, two doors.

Déléguer ce qu'on sait faire, sans être ce qu'on délègue.Delegate what you know how to do, without being what you delegate to.

La composition est l'autre réponse au partage : au lieu d'hériter d'une classe (is-a) ou de mixer un module, on détient un objet (has-a) et on lui délègue ce qu'il sait faire. Forwardable industrialise ce geste : def_delegators expose, une à une, les méthodes qu'on choisit de faire suivre à l'objet contenu — et seulement celles-là. La surface reste sous contrôle : Playlist a un tableau, en publie quatre méthodes, et garde le droit d'en ajouter ou d'en cacher. include Enumerable, lui, rebranche tout le réflexe fonctionnel du Vol 8 sur un simple each.Composition is the other answer to sharing: instead of inheriting a class (is-a) or mixing a module, you hold an object (has-a) and delegate to it what it knows how to do. Forwardable industrializes this: def_delegators exposes, one by one, the methods you choose to forward to the contained object — and only those. The surface stays under control: Playlist has an array, publishes four of its methods, and keeps the right to add or hide. include Enumerable, meanwhile, wires the whole functional reflex of Vol 8 onto a single each.

require "forwardable"

class Playlist
  extend Forwardable                       # extend : méthodes de classe
  def_delegators :@songs, :each, :size, :<<, :empty?   # délègue à @songs

  include Enumerable                        # via each → map/select/sort… gratis

  def initialize = @songs = []
  def total_minutes = @songs.sum(&:minutes) # le comportement PROPRE à Playlist
end

list = Playlist.new
list << song            # délégué à @songs.<<
list.size               # délégué à @songs.size
list.map(&:title)       # via Enumerable, sur la base d'each

# is-a (héritage)            vs   has-a (composition)
class Playlist < Array          class Playlist
  # EST un Array :                 def initialize = @songs = []
  # hérite ~100 méthodes          # A un Array, en expose 4 :
end                               #   each, size, <<, empty?
                                end

La grille du volume se complète : :: pour nommer, include pour donner aux instances, extend pour donner à un objet, et la composition quand on ne veut ni être ni mixer, mais déléguer. Quatre outils, une seule question à chaque fois — quelle relation, exactement, lie mon objet à ce comportement ?The volume's grid completes: :: to name, include to give to instances, extend to give to an object, and composition when you want neither to be nor to mix, but to delegate. Four tools, one question each time — what relationship, exactly, ties my object to this behavior?

Sous-classer Array pour trois méthodes : cent en cadeau.Subclassing Array for three methods: a hundred for free.

Le contre-exemple obligatoire du volume. On veut une Playlist avec trois méthodes maison, alors on hérite d'Array « pour avoir push, size, each gratis ». Mais l'héritage est tout ou rien : on récupère aussi pack, rotate, flatten!, l'opérateur &, cent méthodes dont aucune n'a de sens pour une playlist et qu'on ne contrôle plus. Pire, l'abstraction fuit — first(3), select, map renvoient des Array nus, pas des Playlist : le type s'évapore au premier appel. La composition isolait proprement : Playlist a un tableau, en expose la surface qu'elle choisit, et garde son type de bout en bout.The volume's mandatory counter-example. You want a Playlist with three custom methods, so you inherit from Array 'to get push, size, each for free'. But inheritance is all-or-nothing: you also get pack, rotate, flatten!, the & operator, a hundred methods none of which make sense for a playlist and which you no longer control. Worse, the abstraction leaks — first(3), select, map return bare Arrays, not Playlists: the type evaporates on the first call. Composition isolated cleanly: Playlist has an array, exposes the surface it picks, and keeps its type throughout.

# Sous-classer Array pour ajouter 3 méthodes : on en hérite ~100
class Playlist < Array
  def total_minutes = sum(&:minutes)
  def titles        = map(&:title)
  def shuffle_fair  = sort_by { rand }
end

list = Playlist.new
list.push(song)          # ok… mais aussi pack, rotate, flatten!, &, |, etc.
top3 = list.first(3)     # => un Array NU, plus une Playlist
list.select(&:fav?)      # => un Array NU : l'abstraction fuit dès qu'on filtre
list.class               # Playlist, mais ses dérivés retombent en Array
# on a hérité 100 méthodes qu'on ne contrôle pas, et perdu son type au 1er map

# Composition : Playlist A un tableau, n'EST PAS un tableau
require "forwardable"

class Playlist
  extend Forwardable
  def_delegators :@songs, :size, :<<, :each, :empty?
  include Enumerable                      # map/select via each…

  def initialize(songs = []) = @songs = songs
  def total_minutes = @songs.sum(&:minutes)
  def select(&blk) = Playlist.new(@songs.select(&blk))  # garde le TYPE
end

list = Playlist.new
list << song
list.select(&:fav?)      # => une Playlist, surface maîtrisée de bout en bout