Quand le canard trahit — frontières & types optionnels When the duck betrays you — boundaries & optional types

Le canard finit par trahir — et toujours au pire endroit.The duck eventually betrays you — always at the worst place.

Deux numéros à vanter le duck typing ; voici sa facture, en toute honnêteté. Quand on fait confiance au message sans jamais vérifier, une donnée malformée traverse sans bruit — et l'erreur n'éclate pas là où elle est née (l'entrée), mais douze appels plus loin, au fond du domaine, sous la forme d'un NoMethodError sur nil. Le bug que Rust attrape à la compilation, Ruby te le sert à l'exécution, au moment le moins commode.Two issues praising duck typing; here's its bill, honestly. When you trust the message without ever checking, malformed data flows through silently — and the error doesn't surface where it was born (the entry), but twelve calls deep, in the domain, as a NoMethodError on nil. The bug Rust catches at compile time, Ruby serves you at runtime, at the least convenient moment.

# à l'entrée HTTP : on fait confiance au JSON reçu, sans rien vérifier
payload = JSON.parse(request.body)     # { } — "name" est absent ce jour-là
user = User.new(payload)

# … 12 frames plus loin, au fond de la couche de rendu :
def greeting(user) = "Bonjour #{user.name.split.first} !"

greeting(user)
# NoMethodError: undefined method 'split' for nil
#   app/views/header.rb:7   ← l'erreur surgit ICI…
#   … mais la cause est à l'entrée HTTP, douze appels plus haut

Le bug ne change pas. Ce qui change, c'est où il éclate.The bug doesn't change. What changes is where it surfaces.

La donnée malformée provoquera une erreur de toute façon — la question n'est pas « si » mais « où ». Sans frontière, elle voyage au cœur du domaine et explose à des frames de sa cause, sur un nil cryptique. Avec une frontière, tu la valides une seule fois à l'entrée : l'erreur naît là, avec un message qui nomme le champ fautif, et tout le code en aval peut faire confiance. Déplacer l'erreur vers sa cause, c'est tout l'enjeu.The malformed data will cause an error anyway — the question isn't 'whether' but 'where'. Without a boundary, it travels into the domain and blows up frames away from its cause, on a cryptic nil. With a boundary, you validate it once at the entry: the error is born there, with a message naming the offending field, and all downstream code can trust. Moving the error toward its cause is the whole point.

# Sans frontière : la donnée brute circule, et trahit où elle veut
def create_user(params)        # params : un Hash venu de nulle part de sûr
  Account.new(params)          # on transmet tel quel
end

def charge(account)            # … bien plus loin
  account.balance * 1.2        # NoMethodError si balance est nil/absent
end                            # l'erreur naît ICI, la cause est à l'entrée

Le Hash brut circule de méthode en méthode. Personne ne s'engage sur son contenu, donc l'erreur attend le dernier moment — un NoMethodError dans charge, alors que le vrai coupable est create_user, voire l'appelant HTTP au-dessus.The raw Hash flows from method to method. No one commits to its contents, so the error waits until the last moment — a NoMethodError in charge, while the real culprit is create_user, or even the HTTP caller above.

Deux façons de regagner la garantie : à l'exécution, ou à l'analyse.Two ways to regain the guarantee: at runtime, or at analysis.

« Valider à la frontière » a deux outils, qui répondent à la même question à deux endroits différents. dry-struct vérifie et coerce la donnée AU RUNTIME, une fois, à l'entrée : après ça, le domaine fait confiance. Steep + RBS ajoutent un typage statique graduel par-dessus le code, vérifié HORS exécution : pour les frontières qu'on veut prouver sans payer un contrôle à chaque appel. L'un borne la donnée, l'autre prouve le code — et tu choisis lequel, où.'Validate at the boundary' has two tools, answering the same question in two different places. dry-struct checks and coerces data AT RUNTIME, once, at the entry: after that, the domain trusts. Steep + RBS add gradual static typing over the code, checked OUTSIDE execution: for the boundaries you want to prove without paying a check on every call. One bounds the data, the other proves the code — and you choose which, where.

require "dry/struct"
module Types; include Dry.Types(); end

class Order < Dry::Struct
  attribute :id,       Types::Strict::Integer        # exige un Integer, sans coercition
  attribute :amount,   Types::Coercible::Decimal     # "9.90" → 9.90
  attribute :currency, Types::String.enum("EUR", "USD")  # borné à deux valeurs
  attribute :note,     Types::String.optional        # peut être nil, explicitement
end

Order.new(id: 1, amount: "9.90", currency: "EUR", note: nil)
# OK — amount coercé en Decimal, currency validé, note nil autorisé

Order.new(id: "oops", amount: "9.90", currency: "EUR")
# Dry::Struct::Error: [Order.new] "oops" (String) has invalid type for :id
#   violates constraints (type?(Integer, "oops") failed)
#   ↑ à la frontière, message clair, AVANT que la donnée ne voyage

# sig/checkout.rbs — une signature, hors du code, qu'on choisit d'écrire
class Checkout
  def total: (Array[Order]) -> BigDecimal   # une somme de Decimal
end

# checkout.rb
class Checkout
  def total(orders)
    orders.sum { |o| o.amont }   # faute de frappe : amont au lieu d'amount
  end
end

# $ steep check
# checkout.rb:3: [error] Type Order does not have method 'amont'
#   ↑ attrapé SANS exécuter le code, à l'analyse — comme un compilateur

Les deux ne s'opposent pas : dry-struct garde la donnée externe à l'entrée (HTTP, JSON, CSV — ce que les types statiques ne voient pas venir), Steep prouve le code interne que tu choisis d'annoter. La plupart des bases sérieuses utilisent les deux, chacun à sa frontière.The two aren't opposed: dry-struct guards external data at the entry (HTTP, JSON, CSV — what static types can't foresee), Steep proves the internal code you choose to annotate. Most serious codebases use both, each at its boundary.

Typer partout, c'est reconstruire le système rigide qu'on venait de fuir.Typing everywhere rebuilds the rigid system you'd just escaped.

Le danger n'est plus le laxisme, c'est l'excès inverse. Soulagé par dry-struct ou par des signatures RBS, on se met à typer chaque objet de valeur interne, à contrôler le type à l'entrée de chaque méthode privée. On a alors reconstruit, à la main et en plus verbeux, le langage à types que les deux premiers numéros avaient désamorcé : la cérémonie revient, le couplage revient, et les fakes de test redeviennent impossibles. La garantie se gagne à la frontière, pas à chaque ligne.The danger is no longer laxity, it's the opposite excess. Relieved by dry-struct or RBS signatures, you start typing every internal value object, checking types at the entry of every private method. You've then rebuilt, by hand and more verbosely, the typed language the first two issues defused: the ceremony returns, the coupling returns, and test fakes become impossible again. The guarantee is earned at the boundary, not at every line.

# Le réflexe inverse : rassuré par dry-struct, on en met PARTOUT
class Cents < Dry::Struct
  attribute :value, Types::Strict::Integer
end
class TaxRate < Dry::Struct
  attribute :value, Types::Strict::Decimal
end

def apply_tax(cents, rate)
  raise TypeError unless cents.is_a?(Cents)    # contrôle de type interne
  raise TypeError unless rate.is_a?(TaxRate)   # … à chaque méthode
  Cents.new(value: (cents.value * (1 + rate.value)).round)
end
# on a re-typé tout le domaine : cérémonie, couplage, et adieu les fakes
# de test — exactement le système rigide que ce volume a désamorcé

# La frontière typée, l'intérieur en duck typing
class OrderInput < Dry::Struct           # UNE struct, à l'entrée HTTP
  attribute :cents, Types::Coercible::Integer
  attribute :rate,  Types::Coercible::Decimal
end

def apply_tax(cents, rate)               # à l'intérieur : aucun type exigé
  (cents * (1 + rate)).round            # marche pour Integer, Decimal, un fake…
end

input = OrderInput.new(params)           # validé une fois, à la lisière
apply_tax(input.cents, input.rate)       # le domaine fait confiance