L'interface nil qui n'est pas nil The nil interface that isn't nil

Un *T nil rangé dans une interface n'est pas == nil : l'interface porte un type, donc elle est non vide. Le piège trahit le réflexe le plus sacré de Go — if err != nil — et fait passer une erreur absente pour présente. On le voit, on l'explique, on l'évite. A nil *T stored in an interface is not == nil: the interface carries a type, so it's non-empty. The trap betrays Go's most sacred reflex — if err != nil — making an absent error look present. We make it visible, explain it, avoid it.

Audience
Dev qui écrit if err != nil tous les jours et veut comprendre pourquoi il peut mentir Dev who writes if err != nil daily and wants to know why it can lie
ChapitresChapters
5
LectureReading
≈ 16 min
NiveauLevel
●●●○
Date
Jan 2027 Jan 2027

nilInterfacesPiège

SommaireContents ·
№ 01CadrageFraming3 min

Un pointeur nil rangé dans une interface donne une interface qui n'est pas nil.A nil pointer stored in an interface yields an interface that is not nil.

Au numéro précédent, on a vu qu'une valeur d'interface est une paire (type, valeur). C'était une jolie image ; c'est aussi un piège. Car cette paire change le sens de nil. Un pointeur peut être nil — c'est une valeur parfaitement ordinaire. Mais dès qu'on range ce pointeur nil dans une interface, la case « type » se remplit avec son type concret, et l'interface, elle, cesse d'être vide. La comparaison i == nil devient fausse alors même que ce que l'interface contient est nil. C'est le bug le plus déroutant de Go, parce qu'il fait mentir nil — et nil, on lui fait confiance partout.Last issue we saw that an interface value is a (type, value) pair. It was a tidy image; it's also a trap. Because that pair changes the meaning of nil. A pointer can be nil — a perfectly ordinary value. But the moment you store that nil pointer in an interface, the 'type' slot fills with its concrete type, and the interface stops being empty. The comparison i == nil becomes false even though what the interface holds is nil. It's Go's most baffling bug, because it makes nil lie — and nil is something we trust everywhere.

Le mensonge : un nil qui compare fauxThe lie: a nil that compares false
func find() *Node { return nil }     // renvoie un *Node bel et bien nil

var i any = find()                    // on le range dans une interface
fmt.Println(i == nil)                 // false  ← surprise

// le *Node EST nil. L'interface qui le transporte, elle, ne l'est pas.
Le modèle : nil ⇔ les deux cases videsThe model: nil ⇔ both slots empty
// une valeur d'interface = DEUX cases : (type, valeur)
//   var i any            →  (nil,   nil)   →  i == nil   ✓ vrai
//   var p *Node = nil
//   i = p               →  (*Node, nil)   →  i == nil   ✗ faux
// nil ne compare vrai que si les DEUX cases sont vides à la fois.
Les deux cases d'une interfaceAn interface's two slots
type
nil
value
nil
== nil → true
type
*Node
value
nil
== nil → false

À gauche, l'interface vraiment vide : les deux cases à nil, donc == nil vrai. À droite, la même valeur nulle, mais la case « type » porte *Node — l'interface n'est plus vide. Une interface est nil quand son type l'est, pas quand sa valeur l'est.On the left, the truly empty interface: both slots nil, so == nil is true. On the right, the same null value, but the 'type' slot carries *Node — the interface is no longer empty. An interface is nil when its type is, not when its value is.

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

« nil dans une interface ne teste pas la valeur, il teste le type. » Tout le numéro découle de là : pourquoi if err != nil peut trahir, comment l'éviter à la source, et pourquoi le problème dépasse de loin les erreurs. La règle pratique tient en une ligne — ne range jamais un pointeur typé nil dans une interface en espérant qu'elle reste nil."nil in an interface doesn't test the value, it tests the type." The whole issue follows: why if err != nil can betray you, how to avoid it at the source, and why the problem reaches far beyond errors. The practical rule fits on one line — never store a typed nil pointer in an interface and expect it to stay nil.

Pourquoi deux cases, et pas une ?Why two slots, not one?

Parce que l'interface doit savoir QUEL type elle transporte pour appeler la bonne méthode — c'est la satisfaction implicite du numéro précédent qui l'exige. La case « type » n'est pas un caprice : c'est elle qui permet à un même io.Writer d'aiguiller vers Write d'un fichier ou d'un buffer. Le prix de cette souplesse, c'est qu'un type non vide suffit à rendre l'interface non vide — même si la valeur, derrière, est absente. Le typed nil n'est pas un bug du langage : c'est la rançon d'une représentation qui doit retenir le type.Because the interface must know WHICH type it carries to call the right method — the implicit satisfaction of last issue demands it. The 'type' slot isn't a whim: it's what lets one io.Writer dispatch to a file's Write or a buffer's. The price of that flexibility is that a non-empty type alone makes the interface non-empty — even if the value behind it is absent. The typed nil isn't a language bug: it's the ransom of a representation that must remember the type.

№ 02La surpriseThe surprise4 min

Le réflexe le plus sacré de Go — if err != nil — peut mentir.Go's most sacred reflex — if err != nil — can lie.

Voici l'incarnation que tout le monde croise un jour. Une fonction renvoie error, mais à l'intérieur elle manipule une variable d'un type d'erreur concret, *MyError. Quand tout se passe bien, cette variable reste nil — et la fonction la renvoie telle quelle. Sauf qu'au passage, ce *MyError nil est emballé dans l'interface error : la case « type » se remplit, et l'erreur renvoyée n'est plus nil. L'appelant, fidèle au réflexe if err != nil, croit à un échec qui n'a jamais eu lieu. Le code se trompe non par négligence mais par excès de zèle : il a typé son erreur trop tôt.Here's the incarnation everyone meets one day. A function returns error, but inside it handles a variable of a concrete error type, *MyError. When all goes well, that variable stays nil — and the function returns it as is. Except along the way, that nil *MyError gets wrapped in the error interface: the 'type' slot fills, and the returned error is no longer nil. The caller, faithful to the if err != nil reflex, believes in a failure that never happened. The code errs not from neglect but from over-eagerness: it typed its error too early.

Une erreur absente que l'appelant croit présenteAn absent error the caller believes present
type MyError struct{ Code int }
func (e *MyError) Error() string { return fmt.Sprintf("err %d", e.Code) }

func do() error {
    var err *MyError              // type concret, nil
    if somethingBad() {
        err = &MyError{Code: 500}
    }
    return err                    // BUG : si tout va bien, on renvoie un
}                                 // *MyError nil — rangé dans error, non vide

if err := do(); err != nil {      // TOUJOURS vrai, même quand tout va bien
    log.Fatal(err)                // un succès traité comme un échec
}

Le coupable est la variable var err *MyError. Déclarée du type concret, elle peut être nil comme pointeur — mais le return la convertit en error, et cette conversion grave le type *MyError dans la case « type ». L'interface renvoyée porte un type, donc elle n'est pas nil, quoi que vaille le pointeur. Le plus cruel : le code a l'air parfait, il compile, il passe la revue — et il ne casse qu'en production, sur le chemin où tout allait bien.The culprit is the variable var err *MyError. Declared with the concrete type, it can be nil as a pointer — but the return converts it to error, and that conversion engraves the type *MyError into the 'type' slot. The returned interface carries a type, so it isn't nil, whatever the pointer holds. The cruelest part: the code looks perfect, it compiles, it passes review — and only breaks in production, on the path where all was well.

Le linter qui le voit (parfois)The linter that catches it (sometimes)

Le compilateur laisse passer le typed nil — c'est du code valide. Mais le check SA4023 de staticcheck (épaulé par l'analyseur nilness de golang.org/x/tools, intégré à gopls) sait repérer plusieurs formes du piège : une fonction qui renvoie un pointeur typé là où une interface est attendue, une comparaison à nil qui ne peut jamais être vraie. Ajoute staticcheck à ta CI : il ne couvre pas tous les cas — l'emballage indirect lui échappe — mais il attrape les plus fréquents avant qu'ils n'atteignent la prod. Le go vet standard, lui, reste muet sur ce point.The compiler waves the typed nil through — it's valid code. But staticcheck's SA4023 check (backed by the nilness analyzer from golang.org/x/tools, built into gopls) can spot several shapes of the trap: a function returning a typed pointer where an interface is expected, a nil comparison that can never be true. Add staticcheck to your CI: it doesn't cover every case — indirect wrapping slips past it — but it catches the most common ones before they reach prod. Plain go vet stays silent here.

Le bug n'est pas dans le == nil. Il est dans la variable typée que tu as créée trois lignes plus tôt.The bug isn't in the == nil. It's in the typed variable you created three lines earlier.
№ 03La mécaniqueThe mechanics5 min

Ce que == nil teste : la paire entière, jamais la valeur seule.What == nil tests: the whole pair, never the value alone.

Une fois le modèle des deux cases en tête, les règles de comparaison deviennent mécaniques. Comparer une interface à nil, c'est demander « les deux cases sont-elles vides ? ». Comparer deux interfaces, c'est comparer les deux paires, case par case. Une interface qui contient un pointeur nil n'est donc jamais égale à nil : nil, c'est (nil, nil) ; elle, c'est (type, nil). La bonne nouvelle, c'est que ces règles sont parfaitement déterministes — aucune surprise une fois qu'on raisonne en paires. La mauvaise, c'est que si on doit vraiment savoir si la valeur sous l'interface est nulle, il faut sortir la réflexion.Once the two-slot model is in your head, the comparison rules become mechanical. Comparing an interface to nil asks 'are both slots empty?'. Comparing two interfaces compares the two pairs, slot by slot. An interface holding a nil pointer is therefore never equal to nil: nil is (nil, nil); it is (type, nil). The good news is that these rules are perfectly deterministic — no surprises once you reason in pairs. The bad news is that if you genuinely must know whether the value under the interface is null, you have to reach for reflection.

Les comparaisons, lues comme des pairesThe comparisons, read as pairs
var err error            // (nil, nil)
err == nil               // true   — l'interface est vraiment vide

var p *MyError           // p est un pointeur nil
p == nil                 // true   — le pointeur, lui, EST nil

var err2 error = p       // (*MyError, nil) : conversion → le type entre
err2 == nil              // false  — la case « type » n'est plus vide
err2 == err              // false  — (*MyError, nil) ≠ (nil, nil)

Quatre comparaisons, aucune ambiguïté dès qu'on les lit en paires. p == nil est vrai parce que p est un pointeur, et un pointeur n'a qu'une valeur. err2 == nil est faux parce que err2 est une interface, et sa case « type » porte *MyError. Le même nil ne veut pas dire la même chose des deux côtés du signe = : à gauche d'une interface, il signifie « paire vide » ; pour un pointeur, « adresse zéro ». La conversion error = p est l'instant exact où le type s'installe.Four comparisons, zero ambiguity once you read them as pairs. p == nil is true because p is a pointer, and a pointer has only a value. err2 == nil is false because err2 is an interface, and its 'type' slot carries *MyError. The same nil doesn't mean the same thing on both sides of =: against an interface it means 'empty pair'; for a pointer, 'zero address'. The conversion error = p is the exact instant the type moves in.

Corrige la source, pas le site d'appelFix the source, not the call site

La tentation, devant un err != nil qui ment, est de blinder l'appelant — réflexion, double test, comparaison à une sentinelle. C'est traiter le symptôme. La paire (type, nil) a été fabriquée ailleurs, dans une fonction qui a renvoyé un pointeur typé. Le seul bon correctif remonte à cette fonction et lui fait renvoyer un nil littéral. Un site d'appel ne devrait jamais avoir à se défendre contre un typed nil bien formé en amont.The temptation, faced with an err != nil that lies, is to armor the caller — reflection, a double test, a sentinel comparison. That treats the symptom. The pair (type, nil) was manufactured elsewhere, in a function that returned a typed pointer. The only good fix goes back to that function and makes it return a literal nil. A call site should never have to defend itself against a typed nil well-formed upstream.

Deux nil égaux ne suffisent pas.Two equal nils aren't enough.

Subtilité qui referme le sujet : deux interfaces sont égales si leurs DEUX cases le sont. Donc deux typed nils de même type SONT égaux entre eux — (*MyError, nil) == (*MyError, nil) est vrai. Mais aucun des deux n'égale l'interface vide. C'est pour ça qu'on ne peut pas « rattraper » un typed nil en le comparant à un autre nil : il faut viser la case type, pas la valeur. Le seul nil qui vaut nil pour une interface, c'est la paire entièrement vide.A closing subtlety: two interfaces are equal if BOTH slots are. So two typed nils of the same type ARE equal to each other — (*MyError, nil) == (*MyError, nil) is true. But neither equals the empty interface. That's why you can't 'rescue' a typed nil by comparing it to another nil: you must target the type slot, not the value. The only nil that equals nil for an interface is the wholly empty pair.

Un pointeur nil et l'interface qui le contient ne sont pas la même chose. L'un est vide ; l'autre sait juste qu'il l'est.A nil pointer and the interface holding it aren't the same thing. One is empty; the other merely knows that it is.
№ 04Le piègeThe trap4 min

Ce n'est pas un problème d'error. C'est un problème de toutes les interfaces.It's not an error problem. It's an every-interface problem.

On associe le typed nil à if err != nil parce que c'est là qu'il fait le plus mal. Mais error n'a rien de spécial : le piège vaut pour n'importe quelle interface — io.Writer, io.Reader, Stringer, la tienne. Range un *bytes.Buffer nil dans un io.Writer, et tu obtiens une interface non-nil qui passe tous les gardes if w != nil… puis panique au premier Write, quand la méthode déréférence son receveur nil. Pire encore : ce n'est même pas garanti de paniquer. Si la méthode prévoit le receveur nil, l'appel réussit — ce qui rend le typed nil tour à tour explosif et silencieux, selon la méthode appelée.We tie the typed nil to if err != nil because that's where it hurts most. But error isn't special: the trap holds for any interface — io.Writer, io.Reader, Stringer, yours. Store a nil *bytes.Buffer in an io.Writer, and you get a non-nil interface that passes every if w != nil guard… then panics on the first Write, when the method dereferences its nil receiver. Worse still: it's not even guaranteed to panic. If the method handles the nil receiver, the call succeeds — which makes the typed nil by turns explosive and silent, depending on the method called.

Non-nil, donc le garde passe — puis ça exploseNon-nil, so the guard passes — then it blows up
var buf *bytes.Buffer        // nil
var w io.Writer = buf        // (*bytes.Buffer, nil) — w n'est PAS nil

if w != nil {                // vrai : l'interface porte un type
    w.Write([]byte("hi"))    // panic: nil pointer dereference
}
// l'interface est non-nil ET appelable. Le panic ne vient pas de l'appel —
// il vient du déréférencement du receveur nil, à l'intérieur de Write.

Le if w != nil est une fausse sécurité : il teste la paire, qui est non vide, donc il laisse passer. Le danger n'est pas dans l'interface mais dans le receveur qu'elle transporte — un *bytes.Buffer nil que Write va déréférencer. Le typed nil déplace le crash de la comparaison vers l'usage : tu ne le vois pas en gardant l'interface, tu le découvres en l'utilisant. C'est exactement pourquoi il échappe aux revues : le garde a l'air correct.The if w != nil is false safety: it tests the pair, which is non-empty, so it lets things through. The danger isn't in the interface but in the receiver it carries — a nil *bytes.Buffer that Write will dereference. The typed nil moves the crash from the comparison to the use: you don't see it guarding the interface, you discover it using it. That's exactly why it slips past reviews: the guard looks correct.

La discipline en trois tempsThe three-part discipline

Un, garde l'interface vraiment vide tant qu'il n'y a rien : var w io.Writer, jamais un pointeur typé nil. Deux, à la frontière d'une fonction, renvoie le littéral nil plutôt qu'une variable typée. Trois, si nil est une valeur valide pour ton type, écris des méthodes à receveur nil explicitement et documente-le. Le typed nil ne se débogue pas, il se prévient — au moment où la valeur entre dans la paire, jamais au moment où elle en sort.One, keep the interface truly empty while there's nothing: var w io.Writer, never a typed nil pointer. Two, at a function boundary, return the literal nil rather than a typed variable. Three, if nil is a valid value for your type, write nil-receiver methods explicitly and document it. The typed nil isn't debugged, it's prevented — at the moment the value enters the pair, never the moment it leaves.

La paire, on va la rouvrir.The pair, we'll reopen it.

Tout ce numéro joue sur une seule case de la paire : le type, qui rend l'interface non vide. Mais la paire n'est pas qu'un piège — c'est aussi un outil. Le prochain numéro la rouvre volontairement : l'assertion x.(T) et le type switch extraient le type caché et la valeur derrière, pour les manipuler à nouveau comme du concret. Le typed nil était la face sombre de la paire ; les assertions en sont la face utile. Vol. 3 №03 : la valeur derrière l'interface, et ce qu'elle coûte.This whole issue plays on a single slot of the pair: the type, which makes the interface non-empty. But the pair isn't only a trap — it's also a tool. Next issue reopens it deliberately: the x.(T) assertion and the type switch extract the hidden type and the value behind it, to handle them as concrete again. The typed nil was the dark face of the pair; assertions are its useful face. Vol. 3 №03: the value behind the interface, and what it costs.

Une interface non-nil n'est pas une interface sûre. Elle te dit qu'elle porte un type — pas que ce type porte quelque chose.A non-nil interface isn't a safe interface. It tells you it carries a type — not that the type carries anything.
№ 05Bilan & éditoWrap-up & editorial2 min

Le nil d'une interface ne parle pas de la valeur. Il parle du type.An interface's nil doesn't speak of the value. It speaks of the type.

Quatre points tiennent ce numéro. Une interface est une paire (type, valeur), et elle n'est nil que si les deux cases sont vides. D'où le bug roi : renvoyer un pointeur typé nil rend if err != nil menteur — on le corrige en renvoyant le littéral nil. Les comparaisons portent sur la paire entière, jamais sur la valeur seule, et voir sous la paire demande la réflexion. Enfin, le piège n'est pas réservé à error : toute interface peut porter un typed nil, non-nil et tantôt appelable, tantôt explosif. Un seul mot d'ordre : empêche le type d'entrer dans la paire tant qu'il n'y a rien à transporter.Four points hold this issue. An interface is a (type, value) pair, and it's nil only if both slots are empty. Hence the king bug: returning a typed nil pointer makes if err != nil lie — you fix it by returning the literal nil. Comparisons act on the whole pair, never the value alone, and seeing under the pair takes reflection. Finally, the trap isn't reserved for error: any interface can carry a typed nil, non-nil and by turns callable or explosive. One watchword: keep the type from entering the pair while there's nothing to carry.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
La paire (type, valeur)The (type, value) pairUne interface est nil ssi ses deux cases le sont.An interface is nil iff both its slots are.Tu crois que l'interface ne porte que la valeur — et le type t'échappe.You think the interface holds only the value — and the type slips past you.
err != nil menterr != nil liesRenvoie error ou le littéral nil, jamais un pointeur typé nil.Return error or the literal nil, never a typed nil pointer.Un succès est traité comme un échec, sur le chemin où tout allait bien.A success is treated as a failure, on the path where all was well.
ComparerComparing== teste la paire entière ; voir la valeur exige reflect.== tests the whole pair; seeing the value needs reflect.Tu blindes le site d'appel au lieu de corriger la source.You armor the call site instead of fixing the source.
Au-delà de errorBeyond errorToute interface peut porter un typed nil — non-nil, parfois appelable.Any interface can carry a typed nil — non-nil, sometimes callable.Le garde if x != nil passe, puis Write panique sur un receveur nil.The if x != nil guard passes, then Write panics on a nil receiver.
On a appris à se méfier d'une case de la paire. Le prochain numéro apprend à les rouvrir toutes les deux, exprès.We learned to mistrust one slot of the pair. Next issue learns to reopen both, on purpose.
Mot de l'éditeurFrom the editor

Le typed nil n'est pas un défaut de Go. C'est le reçu d'un choix qu'on adore par ailleurs.The typed nil isn't a flaw in Go. It's the receipt for a choice we love elsewhere.

On range volontiers le typed nil au rayon des bizarreries du langage, à côté des pièges qu'on pardonne en soupirant. C'est une erreur de perspective. Si une interface devait être nil dès que sa valeur l'est, elle ne pourrait plus retenir le type — et sans le type, adieu la satisfaction implicite, le dispatch dynamique, tout ce qui fait l'élégance du numéro précédent. La paire (type, valeur) est la condition même de la souplesse qu'on a célébrée. Le typed nil en est la contrepartie exacte : le prix d'une représentation qui doit, à tout instant, savoir ce qu'elle transporte. On ne peut pas vouloir l'interface implicite et refuser sa facture.We readily file the typed nil under language oddities, next to the traps we forgive with a sigh. That's a failure of perspective. If an interface had to be nil the moment its value is, it could no longer hold the type — and without the type, goodbye implicit satisfaction, dynamic dispatch, everything that made last issue elegant. The (type, value) pair is the very condition of the flexibility we celebrated. The typed nil is its exact counterpart: the price of a representation that must, at every instant, know what it carries. You can't want the implicit interface and refuse its bill.

Alors faisons la paix avec la paire — et apprenons à nous en servir. Jusqu'ici on l'a subie : le type s'invitait tout seul et faisait mentir nil. Le prochain numéro inverse le rapport de force. L'assertion x.(T) et le type switch rouvrent la paire à dessein, extraient le type caché et la valeur derrière, et nous rendent le concret quand on en a besoin — pour décoder un any, router selon le type réel, sortir d'une abstraction trop large. Mais rien n'est gratuit : ce déballage a un coût, en allocations et en indirection. Vol. 3 №03 : la valeur derrière l'interface, comment la rouvrir, et quand il vaut mieux ne pas l'avoir emballée.So let's make peace with the pair — and learn to use it. Until now we endured it: the type invited itself in and made nil lie. Next issue flips the balance of power. The x.(T) assertion and the type switch reopen the pair on purpose, extract the hidden type and the value behind it, and hand us back the concrete when we need it — to decode an any, route on the real type, escape an over-wide abstraction. But nothing is free: this unwrapping has a cost, in allocations and indirection. Vol. 3 №03: the value behind the interface, how to reopen it, and when you'd have been better off not wrapping it at all.