L'interface implicite The implicit interface

En Go, un type satisfait une interface sans jamais le déclarer — il suffit qu'il ait les méthodes. L'abstraction appartient à celui qui consomme, pas à celui qui fournit. D'où la règle : accepte des interfaces, retourne des structs. In Go, a type satisfies an interface without ever declaring it — having the methods is enough. The abstraction belongs to the consumer, not the provider. Hence the rule: accept interfaces, return structs.

Audience
Dev qui connaît les interfaces d'un autre langage et veut concevoir des API Go idiomatiques Dev who knows interfaces from another language and wants to design idiomatic Go APIs
ChapitresChapters
5
LectureReading
≈ 17 min
NiveauLevel
●●○○
Date
Déc 2026 Dec 2026

InterfacesDuck typing

SommaireContents ·
№ 01CadrageFraming3 min

Un type ne déclare pas qu'il satisfait une interface. Il l'a, ou il ne l'a pas.A type doesn't declare it satisfies an interface. It has it, or it doesn't.

On quitte la concurrence pour le système de types, et on commence par sa pièce la plus déroutante quand on vient d'ailleurs : l'interface. Dans la plupart des langages, un type annonce les interfaces qu'il implémente — implements Comparable, : IDisposable. En Go, ce lien n'existe pas. Une interface est une liste de méthodes ; tout type qui possède ces méthodes la satisfait, automatiquement, sans le savoir et sans rien signer. La satisfaction est structurelle, pas déclarée. Ça change tout : qui possède l'abstraction, où elle vit, et comment on conçoit ses API.We leave concurrency for the type system, and we start with its most disorienting piece when you come from elsewhere: the interface. In most languages, a type announces the interfaces it implements — implements Comparable, : IDisposable. In Go, that link doesn't exist. An interface is a list of methods; any type holding those methods satisfies it, automatically, without knowing and without signing anything. Satisfaction is structural, not declared. That changes everything: who owns the abstraction, where it lives, and how you design your APIs.

Le réflexe explicite : chercher le « implements » qui n'existe pasThe explicit reflex: looking for an 'implements' that isn't there
// le réflexe venu des langages à interfaces explicites
type Stringer interface { String() string }

type Point struct{ X, Y int }

// on cherche le mot-clé qui relie le type à l'interface…
//   class Point implements Stringer  ← Java / C#
// … ce mot-clé n'existe pas en Go. Il n'y a rien à déclarer.
La satisfaction implicite : avoir la méthode suffitImplicit satisfaction: having the method is enough
func (p Point) String() string {        // on écrit juste la méthode
    return fmt.Sprintf("(%d,%d)", p.X, p.Y)
}
// c'est tout : Point satisfait Stringer, sans l'avoir jamais nommée.
// fmt l'accepte déjà — alors que Point n'a jamais entendu parler de fmt.
Un type, des interfaces qu'il n'a jamais nomméesOne type, interfaces it never named
Buffer
type concretconcrete type
⟶
Stringer
String()
satisfaite ✓satisfied ✓
Writer
Write()
satisfaite ✓satisfied ✓
any
—
satisfaite ✓satisfied ✓

Le même Buffer satisfait toutes les interfaces dont il a les méthodes, à la fois, sans en citer une seule. On peut même écrire une interface après le type et il la satisfera rétroactivement. L'interface ne vit pas dans le type — elle vit dans le regard qu'on porte sur lui.The same Buffer satisfies every interface whose methods it has, all at once, without naming a single one. You can even write an interface after the type and it will satisfy it retroactively. The interface doesn't live in the type — it lives in how you look at it.

Le réflexe du numéroThe issue's reflex

« L'abstraction n'appartient pas à celui qui fournit le type, mais à celui qui le consomme. » Puisqu'un type satisfait une interface sans la déclarer, c'est l'appelant qui choisit l'abstraction qui l'intéresse. Tout le numéro déroule la maxime qui en découle : accepte des interfaces, retourne des structs."The abstraction belongs not to whoever provides the type, but to whoever consumes it." Since a type satisfies an interface without declaring it, the caller picks the abstraction it cares about. The whole issue unrolls the maxim that follows: accept interfaces, return structs.

Vérifié à la compilation, pas à l'exécution.Checked at compile time, not at runtime.

« Implicite » ne veut pas dire « magique » ou « tardif ». Le compilateur vérifie au moment où tu passes un Point là où une Stringer est attendue : s'il manque une méthode, ça ne compile pas, avec un message qui dit laquelle. Ce n'est pas du duck typing à la Python résolu à l'exécution — c'est du typage structurel statique. La souplesse est dans la déclaration absente, pas dans la sûreté : celle-ci reste totale. Pour forcer la vérification tôt, on écrit var _ Stringer = Point{}.'Implicit' doesn't mean 'magic' or 'late.' The compiler checks at the moment you pass a Point where a Stringer is expected: if a method is missing, it won't compile, with a message naming which one. This isn't Python-style duck typing resolved at runtime — it's static structural typing. The flexibility is in the absent declaration, not in the safety, which stays total. To force the check early, you write var _ Stringer = Point{}.

№ 02La surpriseThe surprise4 min

L'interface n'appartient pas au type. Elle appartient à celui qui l'appelle.The interface doesn't belong to the type. It belongs to whoever calls it.

Puisqu'un type satisfait une interface sans la déclarer, rien n'oblige à définir l'interface près du type. L'idiome Go fait l'inverse de l'instinct : on déclare l'interface du côté qui consomme, pas du côté qui fournit — et on la garde minuscule. Le fournisseur expose des structs concrètes avec toutes leurs méthodes ; chaque appelant taille, chez lui, la petite interface correspondant exactement à ce dont il se sert. « Plus l'interface est grande, plus l'abstraction est faible », dit Rob Pike. Les interfaces canoniques de Go le prouvent : io.Reader et io.Writer ont une méthode chacune.Since a type satisfies an interface without declaring it, nothing forces you to define the interface near the type. The Go idiom inverts the instinct: you declare the interface on the consuming side, not the providing side — and you keep it tiny. The provider exposes concrete structs with all their methods; each caller carves, on its own side, the small interface matching exactly what it uses. 'The bigger the interface, the weaker the abstraction,' says Rob Pike. Go's canonical interfaces prove it: io.Reader and io.Writer have one method each.

Tout le monde dépend de toutEveryone depends on everything
// le FOURNISSEUR publie une grosse interface « au cas où »
type Store interface {
    Get(id string) (Item, error)
    Put(id string, it Item) error
    Delete(id string) error
    List() ([]Item, error)
    Count() (int, error)
    // … et sept autres méthodes
}
// un appelant qui ne fait QUE lire dépend quand même des douze.

Quand le fournisseur publie une interface qui couvre « tout ce qu'on pourrait vouloir », chaque appelant en hérite en entier, même pour lire un seul champ. Le couplage devient maximal : ajouter une méthode à Store oblige tous les faux objets de test à l'implémenter, et un lecteur ne peut plus être satisfait par un type qui ne sait que lire. La grosse interface fait porter à tous le poids des besoins de chacun.When the provider publishes an interface covering "everything one might want," every caller inherits the whole thing, even to read a single field. Coupling becomes maximal: adding a method to Store forces every test fake to implement it, and a reader can no longer be satisfied by a type that only knows how to read. The fat interface makes everyone carry the weight of everyone's needs.

io.Reader : une méthode, tout l'écosystèmeio.Reader: one method, the whole ecosystem

L'abstraction la plus réutilisée de Go est minuscule : Read(p []byte) (int, error). Une seule méthode, et pourtant fichiers, sockets, buffers, archives gzip, réponses HTTP la satisfont tous. Parce qu'elle est petite, énormément de types l'habitent, et tout ce qui consomme un Reader marche avec n'importe lequel. La largeur de l'écosystème est inversement proportionnelle à la taille de l'interface.Go's most reused abstraction is tiny: Read(p []byte) (int, error). A single method, yet files, sockets, buffers, gzip archives, HTTP responses all satisfy it. Because it's small, enormously many types inhabit it, and anything consuming a Reader works with any of them. The breadth of the ecosystem is inversely proportional to the size of the interface.

L'interface vit dans le paquet consommateur.The interface lives in the consumer package.

Conséquence concrète : ton paquet « stockage » n'a pas à exporter une interface Store. Il exporte un *PostgresStore concret. C'est le paquet « web », qui s'en sert, qui définit son Getter local. Avantage : aucune dépendance du fournisseur vers le consommateur, et autant de petites interfaces que de besoins. Le contre-exemple, ce sont les paquets qui publient une interface pour leur unique implémentation — une indirection sans abstraction, qu'on appelle « interface pollution ».Concrete consequence: your 'storage' package needn't export a Store interface. It exports a concrete *PostgresStore. It's the 'web' package, the one using it, that defines its local Getter. Upside: no dependency from provider to consumer, and as many small interfaces as there are needs. The counter-example is packages that publish an interface for their single implementation — indirection without abstraction, what people call 'interface pollution.'

Ne demande pas « quelles méthodes ce type a-t-il ? ». Demande « de quelles méthodes ai-je besoin ? » — et n'écris que celles-là.Don't ask "what methods does this type have?" Ask "what methods do I need?" — and write only those.
№ 03La mécaniqueThe mechanics5 min

« Accepte des interfaces » : demande un comportement, pas un type."Accept interfaces": ask for a behaviour, not a type.

Première moitié de la maxime. Quand une fonction prend un paramètre, qu'elle demande l'interface la plus étroite qui couvre ce qu'elle fait, jamais un type concret. La différence paraît cosmétique ; elle est structurelle. Un paramètre concret cloue l'appelant à une implémentation précise — un vrai fichier, une vraie connexion, une vraie horloge. Un paramètre interface n'exige qu'un comportement, donc accepte tout ce qui sait l'exhiber : la vraie chose en prod, un faux trivial en test. C'est le même mécanisme qui rend Go testable sans framework de mock, et découplé sans injection de dépendances cérémonieuse.First half of the maxim. When a function takes a parameter, have it ask for the narrowest interface covering what it does, never a concrete type. The difference looks cosmetic; it's structural. A concrete parameter nails the caller to one implementation — a real file, a real connection, a real clock. An interface parameter demands only a behaviour, so it accepts anything that can exhibit it: the real thing in prod, a trivial fake in test. It's the same mechanism that makes Go testable without a mocking framework, and decoupled without ceremonious dependency injection.

Le type concret cloue l'appelant au systèmeThe concrete type nails the caller to the system
// dépendance sur un TYPE concret : *os.File
func Save(f *os.File, data []byte) error {
    _, err := f.Write(data)
    return err
}
// pour tester, il faut un vrai fichier sur le disque :
//   tmp, _ := os.CreateTemp("", "t"); Save(tmp, ...)
// … nettoyage, droits, chemins. Le test dépend du système de fichiers.

En exigeant un *os.File, Save ne sait écrire que sur le disque. Pourtant elle n'utilise qu'une méthode, Write — tout le reste de *os.File (les permissions, le descripteur, Seek, Stat) lui est inutile. Elle demande bien plus qu'elle n'emploie, et le fait payer à chaque appelant : impossible d'écrire ailleurs, impossible de tester sans toucher le système de fichiers. Le besoin réel était minuscule ; la signature l'a rendu énorme.By requiring a *os.File, Save can only write to disk. Yet it uses a single method, Write — all the rest of *os.File (permissions, the descriptor, Seek, Stat) is useless to it. It asks for far more than it uses, and bills every caller for it: can't write anywhere else, can't test without touching the filesystem. The real need was tiny; the signature made it huge.

L'horloge, l'exemple qui éclaire toutThe clock, the example that lights it up

Une fonction qui appelle time.Now() en dur est intestable : son résultat change à chaque seconde. Fais-lui plutôt accepter une petite interface — type Clock interface { Now() time.Time } — et passe la vraie horloge en prod, une horloge figée en test. Soudain « est-ce que le ticket expire après 24 h ? » devient un test déterministe. Tout ce qui rend une fonction non déterministe — temps, hasard, réseau, disque — devrait entrer par une interface, pas être appelé en dur à l'intérieur.A function that calls time.Now() directly is untestable: its result changes every second. Instead have it accept a small interface — type Clock interface { Now() time.Time } — and pass the real clock in prod, a frozen one in test. Suddenly "does the ticket expire after 24h?" becomes a deterministic test. Everything that makes a function non-deterministic — time, randomness, network, disk — should enter through an interface, not be called directly inside.

Une fonction qui demande un type concret dit « fais-le exactement comme ça ». Une fonction qui demande une interface dit « apporte-moi ce comportement, peu importe d'où ».A function asking for a concrete type says "do it exactly this way." A function asking for an interface says "bring me this behaviour, from wherever."
№ 04Le piègeThe trap4 min

« Retourne des structs » : ne décide pas, à la place de l'appelant, de ce qu'il perd."Return structs": don't decide, for the caller, what they get to lose.

Seconde moitié de la maxime, et le vrai piège du numéro. Demander des interfaces en entrée élargit ce qu'on accepte ; retourner une interface en sortie rétrécit ce qu'on rend. Au moment où une fonction renvoie une interface plutôt que le type concret, elle ampute l'appelant de tout ce qui n'est pas dans cette interface — champs, méthodes additionnelles, types futurs. Et comme un type satisfait déjà toutes ses interfaces implicitement, rendre le struct ne coûte rien : l'appelant le réduira à l'abstraction qu'il veut, s'il en veut une. La symétrie est nette : sois libéral sur ce que tu acceptes, généreux sur ce que tu rends.Second half of the maxim, and the issue's real trap. Asking for interfaces on input widens what you accept; returning an interface on output narrows what you give back. The moment a function returns an interface rather than the concrete type, it amputates the caller of everything not in that interface — fields, extra methods, future types. And since a type already satisfies all its interfaces implicitly, returning the struct costs nothing: the caller will reduce it to whatever abstraction it wants, if it wants one. The symmetry is clean: be liberal in what you accept, generous in what you return.

L'interface en sortie enferme l'appelantThe interface on output boxes the caller in
// retourner une INTERFACE depuis un constructeur
func NewClient() Doer {            // Doer = une seule méthode, Do()
    return &client{timeout: 30}
}
// l'appelant ne voit plus que Do() :
//   c := NewClient()
//   c.SetTimeout(10)   // ERREUR compile : Doer n'a pas SetTimeout
// et un retour nil typé devient un nil… qui n'est pas nil → Vol. 3 №02

En rendant un Doer, le constructeur a choisi pour l'appelant la seule chose qu'il aura le droit de faire. Toute méthode concrète — configurer, inspecter, fermer — disparaît derrière l'interface, et le jour où tu en ajoutes une, personne ne peut l'atteindre sans assertion de type. Pire, c'est ici que naît le bug le plus déroutant de Go : un pointeur nil enveloppé dans une interface n'est pas un nil. Le retour interface fabrique des « nil qui ne sont pas nil » — on y revient au prochain numéro.By returning a Doer, the constructor chose for the caller the only thing it'll be allowed to do. Every concrete method — configure, inspect, close — vanishes behind the interface, and the day you add one, no one can reach it without a type assertion. Worse, this is where Go's most baffling bug is born: a nil pointer wrapped in an interface is not a nil. Returning interfaces manufactures "nils that aren't nil" — more on that next issue.

L'exception : error, et seulement elleThe exception: error, and only it

La règle a une exception assumée : on retourne error, qui est une interface. C'est voulu — l'appelant ne doit dépendre que du contrat Error() string, pas du type concret de l'erreur, pour pouvoir comparer et envelopper librement (Vol. 4). Mais c'est justement cette exception qui expose le piège : renvoyer un *MonErreur nil dans un error donne une error != nil. La bonne pratique — return nil explicite, jamais une variable typée nil — découle directement de la mécanique des valeurs d'interface.The rule has one deliberate exception: you return error, which is an interface. That's intended — the caller should depend only on the Error() string contract, not on the error's concrete type, so it can compare and wrap freely (Vol. 4). But it's precisely this exception that exposes the trap: returning a nil *MyError as an error yields error != nil. The good practice — an explicit return nil, never a typed nil variable — follows directly from how interface values work.

Le nil qui n'est pas nil.The nil that isn't nil.

Garde cette image pour le prochain numéro : une valeur d'interface, ce sont deux cases — un type et une valeur. Elle n'est nil que si les DEUX le sont. Mets-y un pointeur nil de type *T, et la case « type » est remplie : l'interface n'est plus nil, même si ce qu'elle contient l'est. C'est la cause numéro un des « comparaisons à nil qui mentent » en Go, et c'est presque toujours un retour interface mal fait qui la déclenche. Vol. 3 №02 ouvre la boîte.Hold this image for next issue: an interface value is two slots — a type and a value. It's nil only if BOTH are. Put a nil *T pointer in it, and the 'type' slot is filled: the interface is no longer nil, even though what it holds is. It's the number-one cause of 'nil comparisons that lie' in Go, and it's almost always a botched interface return that triggers it. Vol. 3 №02 opens the box.

Accepter une interface, c'est dire « je m'adapte à toi ». Retourner une interface, c'est dire « tu t'adapteras à moi » — et c'est rarement à toi de l'imposer.Accepting an interface says "I'll adapt to you." Returning an interface says "you'll adapt to me" — and that's rarely yours to impose.
№ 05Bilan & éditoWrap-up & editorial2 min

L'interface en Go n'est pas un contrat qu'on signe. C'est un besoin qu'on exprime.An interface in Go isn't a contract you sign. It's a need you express.

Quatre points tiennent ce numéro. La satisfaction est implicite : avoir les méthodes suffit, rien à déclarer. L'interface appartient au consommateur, et on la garde minuscule. En entrée, on accepte des interfaces, pour demander un comportement plutôt qu'un type. En sortie, on retourne des structs, pour ne rien amputer de ce que l'appelant pourrait vouloir. Une seule idée les relie : en Go, ce n'est pas le type qui annonce ce qu'il est — c'est l'usage qui révèle ce dont on a besoin.Four points hold this issue. Satisfaction is implicit: having the methods is enough, nothing to declare. The interface belongs to the consumer, and you keep it tiny. On input, you accept interfaces, to ask for a behaviour rather than a type. On output, you return structs, so as not to amputate anything the caller might want. One idea ties them together: in Go, it isn't the type that announces what it is — it's the use that reveals what you need.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
Satisfaction impliciteImplicit satisfactionAvoir les méthodes suffit ; pas de implements.Having the methods is enough; no implements.Tu cherches une déclaration de lien type↔interface qui n'existe pas.You hunt for a type↔interface link declaration that doesn't exist.
Côté consommateurConsumer-sideDéclare l'interface où on l'utilise, et garde-la petite.Declare the interface where it's used, and keep it small.Une grosse interface chez le fournisseur couple tout le monde.A fat interface at the provider couples everyone together.
Accepte des interfacesAccept interfacesEn entrée, demande le comportement le plus étroit.On input, ask for the narrowest behaviour.Un paramètre concret cloue l'appelant et bloque le test.A concrete parameter nails the caller and blocks testing.
Retourne des structsReturn structsEn sortie, rends le type concret (sauf error).On output, return the concrete type (except error).Le retour interface ampute l'appelant — et fabrique des nil trompeurs.Returning an interface amputates the caller — and breeds deceptive nils.
Le volume 2 demandait qui possède cette valeur ? Le volume 3 demande : qui possède l'abstraction ? — et la réponse, encore, est « celui qui s'en sert ».Volume 2 asked who owns this value? Volume 3 asks: who owns the abstraction? — and the answer, again, is "whoever uses it."
Mot de l'éditeurFrom the editor

On ne quitte pas vraiment la concurrence. On la retrouve, déguisée en système de types.We don't really leave concurrency. We meet it again, disguised as the type system.

Le volume 2 répétait une seule idée : la concurrence est une affaire de propriété — à chaque instant, une valeur a un propriétaire, et communiquer, c'est transférer ce titre. Le volume 3 ouvre le système de types, et l'on pourrait croire qu'on change de sujet. On ne change que de décor. L'interface implicite dit exactement la même chose, déplacée d'un cran : ce n'est pas le type qui décrète l'abstraction, c'est l'usage qui la révèle. Le producteur livre une valeur concrète ; le consommateur décide quelle forme il en retient. La forme appartient à qui regarde, comme la valeur appartenait à qui la tenait. Go a une philosophie, et elle est étonnamment cohérente : déplacer l'autorité du fournisseur vers l'usage.Volume 2 repeated a single idea: concurrency is a matter of ownership — at every instant a value has an owner, and to communicate is to transfer that title. Volume 3 opens the type system, and you might think we're changing subjects. We only change scenery. The implicit interface says exactly the same thing, shifted one notch: it isn't the type that decrees the abstraction, it's the use that reveals it. The producer ships a concrete value; the consumer decides what shape it keeps. Shape belongs to whoever looks, as the value belonged to whoever held it. Go has a philosophy, and it's strikingly consistent: move authority from the provider to the use.

Mais cette élégance a un revers, et c'est lui qu'on dissèque au prochain numéro. Si une valeur d'interface n'est pas le type qu'elle contient, mais une paire (type, valeur), alors le « nil » se met à mentir. Un pointeur nil rangé dans une interface produit une interface qui n'est pas nil — et la comparaison la plus banale de Go, if err != nil, se retourne contre toi. C'est le bug que tout gophère rencontre une fois et n'oublie jamais. Vol. 3 №02 : le nil typé, ou pourquoi nil n'est pas toujours nil.But this elegance has a flip side, and that's what we dissect next issue. If an interface value isn't the type it contains but a (type, value) pair, then 'nil' starts to lie. A nil pointer stored in an interface produces an interface that is not nil — and Go's most banal comparison, if err != nil, turns against you. It's the bug every gopher hits once and never forgets. Vol. 3 №02: the typed nil, or why nil isn't always nil.