Enumerable via each, ou le contrat minimal Enumerable via each, or the minimal contract

Écris un seul each — et hérite cinquante méthodes.Write a single each — and inherit fifty methods.

Le Vol 8 récolte le fruit du Vol 2. each n'est pas « la boucle de Ruby » : c'est une méthode à qui on confie un bloc, rappelé une fois par élément. Et c'est exactement le contrat que réclame le module Enumerable — un seul. include Enumerable dans ta classe, définis each en yieldant tes éléments, et tu reçois d'un coup map, select, reduce, sort, min_by, group_by, find, take_while… une cinquantaine de méthodes, toutes construites sur ton each. Tu n'écris pas une bibliothèque de collection : tu déclares comment parcourir, et Enumerable fait le reste.Vol 8 reaps Vol 2's fruit. each isn't 'Ruby's loop': it's a method you hand a block, called once per element. And that's exactly the contract the Enumerable module asks for — just one. include Enumerable in your class, define each by yielding your elements, and you get at once map, select, reduce, sort, min_by, group_by, find, take_while… some fifty methods, all built on your each. You don't write a collection library: you declare how to traverse, and Enumerable does the rest.

class Playlist
  include Enumerable          # le mixin (Vol 5) — il s'appuie sur each
  def initialize(songs) = @songs = songs

  def each(&block)            # LE seul contrat à fournir : yield chaque élément
    @songs.each(&block)
  end
end

list = Playlist.new(songs)
list.map(&:title)            # gratuit
list.select(&:fav?)          # gratuit
list.min_by(&:duration)      # gratuit
list.group_by(&:genre)       # gratuit  — aucune n'a été écrite à la main

Une méthode débloque cinquante — et sur n'importe quelle structure.One method unlocks fifty — and on any structure.

La surprise du numéro : Enumerable ne sait rien de tes données. Un tableau, un arbre, un flux réseau, une plage de dates — peu importe la structure interne. Tout ce qu'il demande, c'est un each qui yielde les éléments dans l'ordre que tu décides. Dès qu'il l'a, map, select, sort, include?, group_by fonctionnent sur ton objet comme sur un Array — alors que ton each fait un parcours d'arbre en profondeur. Tu n'as pas adapté tes données à une interface : tu as déclaré comment les parcourir, et tout le vocabulaire fonctionnel s'est greffé dessus.The issue's surprise: Enumerable knows nothing about your data. An array, a tree, a network stream, a date range — the internal structure doesn't matter. All it asks is an each that yields the elements in the order you decide. Once it has that, map, select, sort, include?, group_by work on your object just like on an Array — even though your each does a depth-first tree walk. You didn't adapt your data to an interface: you declared how to traverse it, and the whole functional vocabulary grafted onto that.

class Tree
  def initialize(root) = @root = root
  def each(&block)             # un parcours en profondeur, par exemple
    walk(@root, &block)
  end
  private def walk(node, &block)
    return unless node
    yield node.value
    walk(node.left, &block)
    walk(node.right, &block)
  end
end

# sans include Enumerable : on n'a QUE each
Tree.new(root).map { |v| v * 2 }   # NoMethodError: map

L'arbre sait déjà se parcourir — each fait un joli DFS récursif. Mais sans le mixin, l'objet n'a que each : map lève NoMethodError. On a la moitié du contrat (le parcours), pas encore la récompense.The tree already knows how to traverse itself — each does a neat recursive DFS. But without the mixin, the object has only each: map raises NoMethodError. You have half the contract (the traversal), not yet the reward.

Enumerable appelle ton each — et <=> débloque Comparable pareil.Enumerable calls your each — and <=> unlocks Comparable the same way.

La mécanique n'a rien de magique. Chaque méthode d'Enumerable est écrite en termes de each : map accumule yield(x), select garde ceux qui passent, reduce replie. Elles n'ont aucune autre source d'éléments que ton each — d'où la seule exigence : yielder un à un, dans l'ordre voulu. Le même motif se rejoue un cran plus bas avec Comparable : définis <=> sur ta classe d'élément, include Comparable, et tu obtiens <, >, ==, between?, clamp, plus le sort et le min d'Enumerable qui s'appuient dessus. Deux mixins canoniques, une même idée : un seul contrat débloque toute une famille.The mechanics are no magic. Every Enumerable method is written in terms of each: map accumulates yield(x), select keeps those that pass, reduce folds. They have no element source other than your each — hence the only requirement: yield one at a time, in the intended order. The same pattern plays one rung lower with Comparable: define <=> on your element class, include Comparable, and you get <, >, ==, between?, clamp, plus Enumerable's sort and min that rest on it. Two canonical mixins, one idea: a single contract unlocks a whole family.

# ce que fait, en gros, le map d'Enumerable — sur TON each
module Enumerable
  def map
    result = []
    each { |x| result << yield(x) }   # il appelle TON each, c'est tout
    result
  end
end

# d'où la règle : ton each doit yielder les éléments un à un, dans l'ordre.
# Enumerable ne fait que les relayer au bloc — il n'a aucune autre source.

# même principe, un cran plus bas : <=> débloque Comparable sur l'ÉLÉMENT
class Version
  include Comparable                 # le frère d'Enumerable
  attr_reader :n
  def initialize(n) = @n = n
  def <=>(other) = n <=> other.n     # LE seul contrat de Comparable
  def inspect = n.to_s               # juste pour lire les sorties ci-dessous
end

v = [Version.new(3), Version.new(1), Version.new(2)]
v.sort                               # => [1, 2, 3]  sort utilise <=>
v.min                                # => 1
Version.new(1) < Version.new(2)      # => true  <, >, ==, between?, clamp : gratuits

Un détail pratique : comme map, select & co retournent un Array (pas une instance de ta classe), tu repars d'un tableau ordinaire après transformation. Si tu veux qu'elles te rendent ton type, c'est le terrain de la composition du Vol 5 — mais pour 95 % des cas, hériter d'Enumerable et récupérer un Array est exactement ce qu'on veut.A practical detail: since map, select & co return an Array (not an instance of your class), you continue from a plain array after transforming. If you want them to hand back your type, that's Vol 5's composition ground — but for 95% of cases, inheriting Enumerable and getting an Array back is exactly what you want.

Réécrire map, select, find à la main — une par une, à l'infini.Rewriting map, select, find by hand — one by one, forever.

Le contre-exemple obligatoire du numéro. On a une classe-collection, et on lui ajoute map. Puis on a besoin de select : on l'écrit aussi. Puis find, puis reduce, puis group_by… On réimplémente, une par une, des méthodes qu'un seul include Enumerable aurait toutes données — gratuites, déjà testées par l'équipe Ruby, cohérentes entre elles, et enrichies à chaque version du langage. Chaque méthode écrite à la main est du code à maintenir, à tester, et à garder synchrone avec ses cinquante cousines qu'on n'a pas écrites. Le réflexe : dès qu'on tape def map dans une classe qui sait se parcourir, c'est qu'on aurait dû taper include Enumerable.The issue's mandatory counter-example. You have a collection class, and you add map to it. Then you need select: you write that too. Then find, then reduce, then group_by… You reimplement, one by one, methods a single include Enumerable would have given you all — free, already tested by the Ruby team, consistent with each other, and enriched with every language version. Each hand-written method is code to maintain, to test, and to keep in sync with its fifty cousins you didn't write. The reflex: the moment you type def map in a class that knows how to traverse itself, you should have typed include Enumerable.

# Le piège : réécrire à la main ce qu'Enumerable offrait
class Inventory
  def initialize(items) = @items = items

  def map
    out = []
    @items.each { |i| out << yield(i) }       # on réinvente map…
    out
  end
  def select
    out = []
    @items.each { |i| out << i if yield(i) }  # … et select…
    out
  end
  def find
    @items.each { |i| return i if yield(i) }  # … et find…
    nil
  end
  # et reduce ? group_by ? min_by ? sort_by ? partition ? on en réécrit 50 ?
end

# La même classe, le contrat minimal
class Inventory
  include Enumerable
  def initialize(items) = @items = items
  def each(&block) = @items.each(&block)      # tout tient ici
end

inv = Inventory.new(items)
inv.map { ... }      # ┐
inv.select { ... }   # │  les 50 méthodes, gratuites, testées par Ruby,
inv.find { ... }     # │  cohérentes entre elles, et à jour à chaque version
inv.group_by { ... } # ┘