Les protocoles implicites Implicit protocols

Une seule méthode, et tout le langage te reconnaît.One method, and the whole language recognizes you.

Le duck typing disait : réponds au message. Mais à quels messages ? Ruby en attend certains sans jamais te les déclarer — ce sont ses protocoles implicites. Définis to_s sur ton objet, et d'un coup puts l'affiche, l'interpolation l'insère, print l'accepte. Tu n'as branché ton objet sur rien : tous ces endroits appellent to_s par convention, et ta classe vient de rejoindre une « interface » que personne n'a écrite.Duck typing said: answer the message. But which messages? Ruby expects certain ones without ever declaring them to you — its implicit protocols. Define to_s on your object, and suddenly puts prints it, interpolation inserts it, print accepts it. You wired your object into nothing: all those places call to_s by convention, and your class just joined an 'interface' nobody wrote.

class Temperature
  def initialize(celsius) = @c = celsius
  def to_s = "#{@c} °C"        # je définis UN seul message : to_s
end

t = Temperature.new(21)

puts t                        # 21 °C   — puts a appelé t.to_s
"il fait #{t}"                # "il fait 21 °C"   — l'interpolation aussi
print t, "\n"                # 21 °C   — print aussi
String(t)                     # "21 °C"
# je n'ai jamais "branché" t sur puts : ils appellent to_s par convention

Tu écris une méthode. Tu en récoltes une famille entière.You write one method. You reap a whole family.

La vraie force des protocoles implicites n'est pas l'élégance, c'est le levier. Sans eux, chaque opération de comparaison se réécrit à la main : older_than?, sort_by, min_by, et autant de variantes. Fournis le seul hook <=> et inclus Comparable, et tu obtiens d'un coup <, >, ==, between?, clamp — et sort, min, max sur des collections des tiens. Un message écrit, une famille débloquée.The real power of implicit protocols isn't elegance, it's leverage. Without them, every comparison is hand-rewritten: older_than?, sort_by, min_by, and as many variants. Provide the single hook <=> and include Comparable, and you instantly get <, >, ==, between?, clamp — plus sort, min, max on collections of yours. One message written, a family unlocked.

# Sans protocole : chaque comparaison, à la main, encore et encore
class Version
  attr_reader :parts
  def initialize(str) = @parts = str.split(".").map(&:to_i)

  def older_than?(o) = (parts <=> o.parts) < 0
  def newer_than?(o) = (parts <=> o.parts) > 0
  def same_as?(o)    = parts == o.parts
end

a, b = Version.new("1.2.0"), Version.new("1.10.0")
a.older_than?(b)               # => true
[b, a].sort_by(&:parts)        # tri : encore une méthode ad hoc
[b, a].min_by(&:parts)         # min : et une autre…

Trois méthodes de comparaison maison, et toujours un sort_by / min_by ad hoc à traîner. Ça marche, mais tu réécris ce que Ruby savait déjà faire — et tes objets ne se comparent pas « naturellement » avec < ou sort.Three home-grown comparison methods, and always an ad hoc sort_by / min_by to carry around. It works, but you rewrite what Ruby already knew how to do — and your objects don't compare "naturally" with < or sort.

Le catalogue tacite : quel hook débloque quelle famille.The tacit catalog: which hook unlocks which family.

Ces protocoles ne sont écrits dans aucune interface — ils vivent dans le code de la bibliothèque standard, qui appelle un message convenu sur ce que tu lui donnes. En voici les plus rentables. Et une distinction de plus à connaître : Ruby a des conversions explicites (to_s, to_a, to_i — appelées quand tu le demandes) et des conversions implicites (to_str, to_ary, to_int — que le langage appelle tout seul dans certains contextes).These protocols are written in no interface — they live in the standard library's code, which calls an agreed message on whatever you hand it. Here are the most rewarding. And one more distinction to know: Ruby has explicit conversions (to_s, to_a, to_i — called when you ask) and implicit conversions (to_str, to_ary, to_int — which the language calls on its own in certain contexts).

class Bag
  include Enumerable           # s'appuie sur each
  def initialize(*xs) = @xs = xs
  def each(&block) = @xs.each(&block)   # l'UNIQUE méthode à fournir
end

bag = Bag.new(3, 1, 2)
bag.map { |x| x * 10 }         # => [30, 10, 20]
bag.select(&:odd?)             # => [3, 1]
bag.sort                       # => [1, 2, 3]
bag.min                        # => 1
bag.include?(2)                # => true
# un seul each → des dizaines de méthodes de collection

class Money
  attr_reader :cents
  def initialize(c) = @cents = c
  def *(n) = Money.new(@cents * n)

  def coerce(other)            # le protocole pour "nombre OP mon_objet"
    [self, other]              # * commute : Ruby évaluera money * other
  end
end

money = Money.new(500)
money * 3        # OK : Money#* est appelé
3 * money        # sans coerce → TypeError. Avec : coerce(3) → money * 3

Implémenter la moitié d'un protocole, c'est le casser en silence.Implementing half a protocol is breaking it silently.

Les protocoles implicites donnent beaucoup pour un seul hook — mais certains en exigent plusieurs, cohérents entre eux. L'égalité en est l'exemple piège : == n'est que la moitié visible. uniq, Set et les clés de Hash, eux, s'appuient sur hash et eql?. Définis == sans les deux autres, et tes objets « égaux » ne se dédupliquent pas, ne se retrouvent pas comme clés — sans la moindre erreur pour t'avertir.Implicit protocols give a lot for a single hook — but some demand several, consistent with each other. Equality is the trap case: == is only the visible half. uniq, Set and Hash keys rely on hash and eql?. Define == without the other two, and your 'equal' objects don't dedupe, don't match as keys — with no error to warn you.

class Point
  attr_reader :x, :y
  def initialize(x, y) = (@x, @y = x, y)
  def ==(other)                       # j'implémente l'égalité… la moitié visible
    other.is_a?(Point) && x == other.x && y == other.y
  end
end

a, b = Point.new(1, 2), Point.new(1, 2)
a == b              # => true   — youpi, l'égalité marche

[a, b].uniq.size    # => 2 !    uniq s'appuie sur hash + eql?, PAS sur ==
Set[a, b].size      # => 2 !    un Set aussi
{ a => "ici" }[b]   # => nil    b ne retrouve pas la clé a
# le protocole d'égalité a DEUX moitiés ; tu n'en as écrit qu'une

# Correctif 1 : implémenter le protocole EN ENTIER, de façon cohérente
class Point
  attr_reader :x, :y
  def initialize(x, y) = (@x, @y = x, y)
  def eql?(other) = other.is_a?(Point) && x == other.x && y == other.y
  alias == eql?
  def hash = [x, y].hash             # deux objets égaux DOIVENT avoir le même hash
end

# Correctif 2 (mieux) : laisser Ruby le faire pour toi
Point = Data.define(:x, :y)          # ==, eql?, hash fournis et cohérents
Set[Point.new(1, 2), Point.new(1, 2)].size   # => 1