Envelopper, dérouler Wrap, unwrap

fmt.Errorf("%w", err) emballe une erreur dans un contexte sans la perdre ; errors.Is et errors.As la retrouvent au fond de la pile. Sentinelle ou typée, l'essentiel est de ne jamais casser la chaîne. fmt.Errorf("%w", err) wraps an error in context without losing it; errors.Is and errors.As find it back at the bottom of the stack. Sentinel or typed, the point is never to break the chain.

Audience
Dev qui sait rendre une erreur, mais bute sur errors.Is / errors.As et le couple %w / %v Dev who can return an error, but trips on errors.Is / errors.As and the %w / %v pair
ChapitresChapters
5
LectureReading
≈ 16 min
NiveauLevel
●●○○
Date
Avr 2027 Apr 2027

ErreursWrappingerrors.Is

SommaireContents ·
№ 01CadrageFraming3 min

Une erreur est une valeur. Et comme toute valeur, on peut l'emboîter dans une autre.An error is a value. And like any value, you can nest it inside another.

Le numéro précédent a posé la règle : en chemin, on n'ajoute que du contexte, on ne traite qu'au sommet. Reste à savoir comment ajouter ce contexte sans rien perdre. Deux verbes s'opposent. Aplatir : fmt.Errorf avec %v transforme l'erreur en texte et la fond dans un message — lisible, mais définitif, l'original n'existe plus. Envelopper : fmt.Errorf avec %w garde l'erreur d'origine vivante, attachée sous la nouvelle, formant une chaîne. Le message affiché est le même ; la différence est invisible à l'écran et décisive dans le code. Une erreur aplatie est une impasse. Une erreur enveloppée est une pile qu'on pourra dérouler, couche après couche, jusqu'à la cause première.The previous issue set the rule: along the way you only add context, you handle only at the top. What remains is how to add that context without losing anything. Two verbs oppose each other. Flatten: fmt.Errorf with %v turns the error into text and melts it into a message — readable, but final, the original no longer exists. Wrap: fmt.Errorf with %w keeps the original error alive, attached beneath the new one, forming a chain. The displayed message is identical; the difference is invisible on screen and decisive in code. A flattened error is a dead end. A wrapped error is a stack you can unroll, layer after layer, down to the first cause.

Aplatir avec %v : le message survit, l'erreur meurtFlatten with %v: the message survives, the error dies
// %v : on aplatit l'erreur en texte. L'original disparaît dans la chaîne.
if err != nil {
    return fmt.Errorf("load config: %v", err)   // %v = juste du texte
}
// l'appelant lit un beau message… mais ne peut plus retrouver
// l'erreur d'origine : os.ErrNotExist s'est dissous dans une string.
Envelopper avec %w : le message ET l'erreur surviventWrap with %w: the message AND the error survive
// %w : on EMBALLE l'erreur. L'original reste accessible, une couche dessous.
if err != nil {
    return fmt.Errorf("load config: %w", err)   // %w = on chaîne
}
// même message à l'écran, mais l'erreur d'origine est conservée :
// errors.Is(err, os.ErrNotExist) la retrouvera au fond de la pile.
Envelopper, c'est chaînerWrapping is chaining
load config
couche 3 · ce que tu lis
›
open /etc/app.conf
couche 2 · contexte
›
os.ErrNotExist
couche 1 · la cause

Chaque %w ajoute une couche par-dessus la précédente, sans écraser ce qu'il y a dessous. Le résultat est une liste chaînée d'erreurs : tu lis la couche du dessus, mais tu peux descendre jusqu'à la cause. Unwrap() retire une couche ; errors.Is et errors.As descendent jusqu'au bout. La chaîne est une structure de données — et on la parcourt.Each %w adds a layer over the previous one, without crushing what lies beneath. The result is a linked list of errors: you read the top layer, but you can descend to the cause. Unwrap() peels one layer; errors.Is and errors.As go all the way down. The chain is a data structure — and you walk it.

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

« En montant, j'enveloppe avec %w ; en descendant, je déroule avec Is et As. » Le numéro défend une idée simple : tant que la chaîne n'est pas cassée, n'importe quelle couche peut interroger n'importe quelle couche du dessous. Casser la chaîne — un %v de trop — c'est jeter cette possibilité, exactement comme un _ = jetait l'erreur entière au numéro précédent."On the way up, I wrap with %w; on the way down, I unroll with Is and As." The issue argues one simple thing: as long as the chain isn't broken, any layer can interrogate any layer beneath it. Breaking the chain — one %v too many — throws that possibility away, exactly as a _ = threw the whole error away last issue.

Un %w par appel, pas plus.One %w per call, no more.

Dans l'usage courant, fmt.Errorf n'a qu'un verbe %w par message : une erreur enveloppe une autre erreur. C'est cohérent avec l'idée de chaîne — une liste a un seul suivant. Depuis Go 1.20, Go sait aussi faire des arbres : fmt.Errorf accepte plusieurs %w, et errors.Join rassemble plusieurs erreurs (toutes les lignes invalides d'un fichier, par exemple) en une seule — errors.Is et errors.As savent les traverser. Mais le cas courant, de loin, reste la chaîne simple : une cause, du contexte ajouté à chaque étage, une couche par return.In everyday use, fmt.Errorf has a single %w verb per message: one error wraps one other error. That fits the chain idea — a list has a single next. Since Go 1.20, Go can build trees too: fmt.Errorf accepts several %w, and errors.Join gathers several errors (every invalid line of a file, say) into one — errors.Is and errors.As can traverse them. But the common case, by far, stays the simple chain: one cause, context added at each floor, one layer per return.

№ 02La surpriseThe surprise4 min

Le == qui marchait au numéro 1 cesse de marcher dès qu'on enveloppe l'erreur.The == that worked in issue 1 stops working the moment you wrap the error.

Le numéro précédent comparait une erreur à une sentinelle avec un simple ==. C'était vrai — tant que personne n'enveloppait l'erreur entre sa source et le test. Mais dès qu'une couche intermédiaire ajoute du contexte avec %w, la valeur que tu reçois n'est plus la sentinelle : c'est l'emballage qui la contient. Le == compare l'identité du dessus, voit un *fmt.wrapError au lieu de ErrNotFound, et répond non. La branche ne se déclenche plus, sans la moindre erreur de compilation. C'est le piège exact que %w introduit — et errors.Is est sa réponse. Au lieu de comparer une seule couche, il déroule toute la chaîne : il teste err, puis Unwrap(err), puis Unwrap de ça, jusqu'à trouver la sentinelle ou toucher le fond. La question passe de « est-ce exactement cette valeur ? » à « cette valeur, ou quelque chose qu'elle enveloppe, est-elle cette erreur ? ».The previous issue compared an error to a sentinel with a plain ==. It was true — as long as nobody wrapped the error between its source and the test. But the moment an intermediate layer adds context with %w, the value you receive is no longer the sentinel: it's the wrapper containing it. == compares the top identity, sees a *fmt.wrapError instead of ErrNotFound, and answers no. The branch stops firing, without the slightest compile error. That's exactly the trap %w introduces — and errors.Is is its answer. Instead of comparing a single layer, it unrolls the whole chain: it tests err, then Unwrap(err), then Unwrap of that, until it finds the sentinel or hits the bottom. The question shifts from 'is this exactly that value?' to 'is this value, or something it wraps, that error?'

Le == ne voit que la couche du dessus== only sees the top layer
var ErrNotFound = errors.New("not found")

// quelque part en profondeur, l'erreur a été enveloppée :
//   return fmt.Errorf("query user %d: %w", id, ErrNotFound)

if err == ErrNotFound {        // FAUX : err est l'emballage, pas la sentinelle
    return defaultUser, nil    // cette branche ne se déclenche JAMAIS
}
// == compare l'identité de la valeur du dessus — l'emballage —
// jamais celle de l'erreur d'origine, enfouie une couche plus bas.

Le piège est silencieux. Le code compile, les tests sur le chemin nu passent, et le bug n'apparaît que le jour où quelqu'un, plus bas, enveloppe l'erreur pour ajouter du contexte — un geste qu'on lui a appris à faire au numéro précédent. Ton == et son %w sont tous deux corrects ; ensemble ils produisent un bug. La leçon : dès qu'une erreur peut traverser plus d'une fonction avant d'être testée, == ne suffit plus. Considère-le comme réservé au cas local où tu sais que l'erreur n'a pas été emballée.The trap is silent. The code compiles, tests on the bare path pass, and the bug only appears the day someone, further down, wraps the error to add context — a move you taught them last issue. Your == and their %w are both correct; together they produce a bug. The lesson: the moment an error can cross more than one function before being tested, == no longer suffices. Treat it as reserved for the local case where you know the error wasn't wrapped.

Unwrap(), le maillon que toute la chaîne supposeUnwrap(), the link the whole chain assumes

Comment errors.Is descend-il ? Par une convention, pas par magie. Une erreur enveloppante expose une méthode Unwrap() error qui rend la couche du dessous — c'est exactement ce que fmt.Errorf("…: %w", err) génère pour toi. errors.Is ne fait qu'appeler Unwrap en boucle. Si tu écris ton propre type d'erreur enveloppante, ajoute-lui une méthode Unwrap, sinon la chaîne s'arrête à toi et errors.Is devient aveugle à tout ce que tu contiens. Reconnais le motif : c'est la satisfaction implicite du volume 3 — aucune déclaration, juste la méthode, et la bibliothèque standard sait parler à ton type.How does errors.Is descend? By a convention, not magic. A wrapping error exposes an Unwrap() error method returning the layer beneath — exactly what fmt.Errorf("…: %w", err) generates for you. errors.Is just calls Unwrap in a loop. If you write your own wrapping error type, give it an Unwrap method, otherwise the chain stops at you and errors.Is goes blind to everything you contain. Recognize the pattern: it's Volume 3's implicit satisfaction — no declaration, just the method, and the standard library knows how to talk to your type.

Le == demande : « es-tu cette valeur ? » errors.Is demande : « toi, ou ce que tu enveloppes, l'êtes-vous ? »== asks: "are you this value?" errors.Is asks: "you, or what you wrap, are you?"
№ 03La mécaniqueThe mechanics5 min

errors.Is répond oui ou non. errors.As te rend l'erreur typée.errors.Is answers yes or no. errors.As hands you the typed error.

errors.Is suffit quand la question est « laquelle ? » et que la réponse est une sentinelle : oui, c'est un ErrNotExist ; non, c'en est une autre. Mais au numéro précédent, on a vu des erreurs typées — des structs qui portent des champs : le chemin fautif, un code HTTP, le numéro de ligne. Pour celles-là, savoir « oui, c'est de ce type » ne suffit pas : on veut le struct lui-même, pour lire ses champs. C'est le rôle d'errors.As. Il déroule la même chaîne qu'errors.Is, mais au lieu de comparer par identité, il teste le type de chaque couche ; dès qu'une couche est du type cherché, il l'extrait et la dépose dans la variable que tu lui as passée — d'où le pointeur. Si tu as déjà lu le volume 3, tu reconnais le geste : errors.As est l'assertion de type x.(*T), et errors.Is le ==, l'un comme l'autre promenés le long de la chaîne au lieu de s'arrêter à la première couche.errors.Is suffices when the question is 'which one?' and the answer is a sentinel: yes, it's an ErrNotExist; no, it's another. But last issue we saw typed errors — structs carrying fields: the offending path, an HTTP code, the line number. For those, knowing 'yes, it's of that type' isn't enough: you want the struct itself, to read its fields. That's errors.As's job. It unrolls the same chain as errors.Is, but instead of comparing by identity, it tests the type of each layer; the moment a layer is the sought type, it extracts it and deposits it into the variable you passed — hence the pointer. If you've read Volume 3, you recognize the move: errors.As is the type assertion x.(*T), and errors.Is the ==, both walked along the chain instead of stopping at the first layer.

Is : confirmer l'identité, sans rien extraireIs: confirm identity, extract nothing
// errors.Is répond par OUI ou NON : « la chaîne contient-elle CETTE valeur ? »
if errors.Is(err, os.ErrNotExist) {     // sentinelle cherchée par identité
    return defaults, nil                // on sait QUOI : un fichier absent
}
// parfait pour une sentinelle. Mais ici on n'a rien récupéré :
// juste la confirmation que l'erreur est, au fond, un ErrNotExist.

errors.Is est un test de présence : il te dit qu'une valeur précise est quelque part dans la chaîne, et c'est tout. Idéal pour une sentinelle — io.EOF, sql.ErrNoRows, ton propre ErrNotFound — où le simple fait de la reconnaître suffit à choisir une branche. Tu ne récupères aucune donnée, parce qu'une sentinelle n'en porte pas : c'est une valeur-étiquette, pas une valeur-conteneur. Quand l'étiquette suffit, Is est l'outil exact, ni plus ni moins.errors.Is is a presence test: it tells you a precise value is somewhere in the chain, and that's all. Ideal for a sentinel — io.EOF, sql.ErrNoRows, your own ErrNotFound — where merely recognizing it suffices to pick a branch. You recover no data, because a sentinel carries none: it's a label-value, not a container-value. When the label suffices, Is is the exact tool, no more, no less.

La même question, deux profondeursThe same question, two depths

Le volume 3 distinguait x == y (même valeur ?) de x.(T) (de ce type, et donne-le-moi). errors.Is et errors.As sont ces deux gestes, promus pour parcourir une chaîne. Is = comparaison d'identité, déroulée. As = assertion de type, déroulée. Tu connais déjà la mécanique ; seule la profondeur change. C'est la cohérence du langage qui se paie ici : un même couple d'opérations — comparer, asserter — se retrouve du any nu jusqu'au fond d'une pile d'erreurs.Volume 3 distinguished x == y (same value?) from x.(T) (of this type, and give it to me). errors.Is and errors.As are those two moves, promoted to walk a chain. Is = identity comparison, unrolled. As = type assertion, unrolled. You already know the mechanics; only the depth changes. The language's consistency pays off here: one same pair of operations — compare, assert — recurs from a bare any down to the bottom of an error stack.

Le pointeur qu'errors.As réclame.The pointer errors.As demands.

errors.As panique si tu ne lui passes pas un pointeur non-nil vers un type qui implémente error (ou vers une interface). La règle : déclare la variable du type cible (var pathErr *os.PathError), puis passe son ADRESSE (&pathErr). As a besoin de l'adresse pour pouvoir écrire dedans — c'est le même mécanisme que tout argument qu'une fonction doit modifier. Si la cible est elle-même un pointeur, comme *os.PathError, tu passes donc un pointeur de pointeur, **os.PathError, et c'est normal. L'erreur classique du débutant — passer pathErr au lieu de &pathErr — compile (As prend un any) mais panique à l'exécution ; c'est go vet, via son check errorsas, qui te protège ici. Enfin, la cible n'est pas forcément un type concret : un pointeur vers une interface (interface{ Timeout() bool }, par exemple) fait extraire la première erreur de la chaîne qui l'implémente.errors.As panics if you don't pass a non-nil pointer to a type implementing error (or to an interface). The rule: declare the target-typed variable (var pathErr *os.PathError), then pass its ADDRESS (&pathErr). As needs the address to write into it — the same mechanism as any argument a function must modify. If the target is itself a pointer, like *os.PathError, you thus pass a pointer to a pointer, **os.PathError, and that's normal. The classic beginner mistake — passing pathErr instead of &pathErr — compiles (As takes an any) but panics at runtime; it's go vet, through its errorsas check, that protects you here. Finally, the target needn't be a concrete type: a pointer to an interface (interface{ Timeout() bool }, say) extracts the first error in the chain that implements it.

Reconnaître une erreur, c'est Is. L'ouvrir pour lire ce qu'elle porte, c'est As.To recognize an error is Is. To open it and read what it carries is As.
№ 04Le piègeThe trap4 min

Envelopper avec %w, c'est publier l'erreur du dessous. Ce n'est pas toujours ce que tu veux.Wrapping with %w publishes the error beneath. That isn't always what you want.

On a vendu %w comme une vertu : garde la chaîne, ne perds jamais la cause. Mais une chaîne ouverte a un revers que peu voient venir. Si tu enveloppes avec %w l'erreur de ta base de données et la renvoies, tu ne donnes pas qu'un message à ton appelant : tu lui donnes le droit de faire errors.Is et errors.As sur tout ce que contient cette chaîne. L'erreur interne — sql.ErrConnDone, le type du driver — fait désormais partie de ce que ton paquet promet. Le jour où tu changes de base, tu casses le code de quiconque s'appuyait dessus, sans avoir touché à ta signature. Envelopper est donc une décision d'API, pas un réflexe. À l'intérieur d'un paquet, enveloppe librement. À sa frontière, choisis : %w pour ce que tu veux exposer comme contrat, %v — ou une erreur neuve — pour sceller ce qui doit rester ta plomberie.We sold %w as a virtue: keep the chain, never lose the cause. But an open chain has a flip side few see coming. If you wrap your database's error with %w and return it, you don't just give your caller a message: you give them the right to errors.Is and errors.As over everything that chain contains. The internal error — sql.ErrConnDone, the driver's type — is now part of what your package promises. The day you switch databases, you break the code of anyone who leaned on it, without having touched your signature. Wrapping is thus an API decision, not a reflex. Inside a package, wrap freely. At its boundary, choose: %w for what you want to expose as a contract, %v — or a fresh error — to seal what must stay your plumbing.

Enveloppé sans réfléchir : la plomberie devient l'APIWrapped without thinking: the plumbing becomes the API
// %w partout : chaque erreur interne devient une partie de ton API publique
func (s *Store) GetUser(id int) (*User, error) {
    var u User
    err := s.db.QueryRow("SELECT ...", id).Scan(&u.Name)
    if err != nil {
        return nil, fmt.Errorf("get user: %w", err)  // sql.ErrConnDone FUIT
    }
    return &u, nil
}
// l'appelant peut désormais errors.Is(err, sql.ErrConnDone) — il est couplé
// à ton choix de base. Tu passes à un autre driver, et son code casse.

Le danger est sournois parce que ça marche : l'appelant fait errors.Is(err, sql.ErrConnDone), ça réussit, tout le monde est content — jusqu'à la migration. Tu n'as rien promis explicitement, mais la chaîne a fait la promesse à ta place. C'est le même malentendu que partout : ce qui est observable devient, de fait, un contrat. Envelopper systématiquement avec %w à travers une frontière de paquet, c'est exposer toute ton implémentation au nom de la commodité — et perdre la liberté de la changer.The danger is insidious because it works: the caller does errors.Is(err, sql.ErrConnDone), it succeeds, everyone's happy — until the migration. You promised nothing explicitly, but the chain made the promise for you. It's the same misunderstanding as everywhere: what's observable becomes, in effect, a contract. Systematically wrapping with %w across a package boundary exposes your whole implementation in the name of convenience — and loses you the freedom to change it.

Envelopper, c'est publierWrapping is publishing

Le volume 2 disait que fermer un channel, c'est diffuser un signal à tous ceux qui écoutent. Le volume 4 dit la même chose des erreurs : envelopper avec %w, c'est diffuser à tous tes appelants ce qu'il y a dessous. Dans les deux cas, un geste qui paraît local — fermer, envelopper — devient public dès qu'il franchit une frontière. La question n'est jamais « est-ce que je peux ? » mais « qu'est-ce que je promets en le faisant ? ». Une chaîne d'erreurs exposée fait partie de ton API aussi sûrement que tes signatures de fonctions.Volume 2 said that closing a channel broadcasts a signal to everyone listening. Volume 4 says the same of errors: wrapping with %w broadcasts to all your callers what lies beneath. In both cases, a move that looks local — closing, wrapping — becomes public the moment it crosses a boundary. The question is never "can I?" but "what do I promise by doing it?". An exposed error chain is part of your API as surely as your function signatures.

Et l'erreur qu'on n'enveloppe pas du tout.And the failure you don't wrap at all.

Tout ce volume traite l'échec comme une valeur : on la rend, on la teste, on l'enveloppe, on la déroule. Mais il existe une classe de pannes pour lesquelles aucun de ces gestes n'a de sens — celles qui ne sont pas des erreurs attendues mais des invariants rompus : un index hors bornes, une assertion de programme qui devait toujours tenir. Là, retourner une error serait mentir : l'appelant ne peut rien décider de sensé face à un bug du programme lui-même. C'est le territoire de panic — et de recover, son unique frontière. Vol. 4 №03 — panic/recover, la frontière. Quand la valeur cède la place à la rupture, et pourquoi c'est, justement, une rupture.This whole volume treats failure as a value: you return it, test it, wrap it, unroll it. But there's a class of failures for which none of these moves makes sense — those that aren't expected errors but broken invariants: an out-of-bounds index, a program assertion that was always meant to hold. There, returning an error would be a lie: the caller can decide nothing sensible against a bug in the program itself. That's the territory of panic — and of recover, its sole boundary. Vol. 4 №03 — panic/recover, the boundary. When value gives way to rupture, and why it is, precisely, a rupture.

%w ouvre la chaîne à ton appelant. %v la referme. Choisir, c'est dessiner ton API.%w opens the chain to your caller. %v closes it. Choosing is drawing your API.
№ 05Bilan & éditoWrap-up & editorial2 min

Une erreur n'est pas qu'une valeur qu'on rend. C'est une valeur qu'on compose.An error isn't just a value you return. It's a value you compose.

Le numéro précédent posait l'erreur-valeur ; celui-ci en fait une structure. Envelopper avec %w empile les contextes sans perdre la cause, formant une chaîne. errors.Is la déroule pour reconnaître une sentinelle là où == échouait dès le premier emballage. errors.As la déroule pour extraire une erreur typée et lire ses champs — l'assertion du volume 3, promenée le long de la pile. Et %w contre %v n'est pas une question de style mais d'API : envelopper, c'est publier ce qu'il y a dessous. À l'intérieur d'un paquet, on enveloppe ; à sa frontière, on choisit ce qu'on expose. Le fil de tout le volume tient là : le contrôle reste dans la main, jusque dans la façon dont l'échec se transmet.The previous issue laid down the error-value; this one makes it a structure. Wrapping with %w stacks contexts without losing the cause, forming a chain. errors.Is unrolls it to recognize a sentinel where == failed at the first wrap. errors.As unrolls it to extract a typed error and read its fields — Volume 3's assertion, walked along the stack. And %w versus %v isn't a matter of style but of API: wrapping publishes what lies beneath. Inside a package you wrap; at its boundary you choose what to expose. The thread of the whole volume holds there: control stays in the hand, down to the way failure is passed on.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
EnvelopperWrapfmt.Errorf("…: %w", err) chaîne la cause sous le contexte.fmt.Errorf("…: %w", err) chains the cause beneath the context.Un %v, et l'erreur d'origine se dissout dans du texte.One %v, and the original error dissolves into text.
errors.Iserrors.IsDéroule la chaîne et compare une sentinelle par identité.Unrolls the chain and compares a sentinel by identity.Un == sur une erreur emballée : la branche ne se déclenche jamais.A == on a wrapped error: the branch never fires.
errors.Aserrors.AsDéroule, extrait une erreur typée dans un pointeur.Unrolls, extracts a typed error into a pointer.Une assertion x.(T) directe rate l'erreur enveloppée d'un cran.A direct x.(T) assertion misses the error wrapped one notch down.
La frontièreThe boundary%w pour exposer un contrat ; %v pour sceller la plomberie.%w to expose a contract; %v to seal the plumbing.Tu enveloppes tout, et ton implémentation devient ton API.You wrap everything, and your implementation becomes your API.
Le numéro 1 t'apprenait à rendre une erreur. Celui-ci t'apprend à la lire au fond de la pile, sans jamais casser ce qui l'a portée jusque-là.Issue 1 taught you to return an error. This one teaches you to read it at the bottom of the stack, without ever breaking what carried it there.
Mot de l'éditeurFrom the editor

Si une erreur est une valeur, alors une chaîne d'erreurs est une structure de données — et tout le reste suit.If an error is a value, then a chain of errors is a data structure — and everything else follows.

C'est la beauté discrète de errors.Is et errors.As : ils n'ont rien inventé. Une fois admis qu'une erreur est une valeur ordinaire, l'envelopper dans une autre n'est qu'une composition de valeurs — une liste chaînée, le plus banal des objets. Et dérouler cette liste pour y chercher une identité ou un type, ce sont les deux seules opérations que le volume 3 nous avait déjà données : la comparaison ==, et l'assertion de type x.(T). errors.Is est l'une, errors.As est l'autre, étendues pour marcher le long de la chaîne au lieu de s'arrêter à la première couche. Rien de neuf, donc — juste la cohérence du langage qui se déploie : les mêmes outils, du any le plus nu jusqu'au fond d'une pile d'erreurs. Là où d'autres langages auraient ajouté une hiérarchie de classes d'exceptions, des catch typés, une machinerie dédiée, Go a dit : c'est déjà une valeur, tu sais déjà la manipuler.That's the quiet beauty of errors.Is and errors.As: they invented nothing. Once you accept that an error is an ordinary value, wrapping it in another is just a composition of values — a linked list, the most mundane of objects. And unrolling that list to seek an identity or a type, those are the only two operations Volume 3 had already handed us: the == comparison, and the type assertion x.(T). errors.Is is one, errors.As the other, extended to walk along the chain instead of stopping at the first layer. Nothing new, then — just the language's consistency unfolding: the same tools, from the barest any down to the bottom of an error stack. Where other languages would have added a hierarchy of exception classes, typed catches, dedicated machinery, Go said: it's already a value, you already know how to handle it.

Et pourtant, ce volume garde une dernière marche. Tout ce qu'on a fait suppose une chose : que l'échec soit une valeur — quelque chose qu'on peut rendre, et que l'appelant peut décider de gérer. Mais il existe des pannes qui ne sont pas des valeurs négociables : un invariant rompu, un état qui ne devait jamais exister, un bug du programme contre lui-même. Face à cela, rendre une error serait un mensonge poli — il n'y a rien à décider, il y a à s'arrêter. C'est là que le langage change de registre : panic n'est pas une exception, recover n'est pas un catch, et la frontière entre les deux mondes — la valeur qu'on compose et la rupture qu'on contient — est précisément ce que le prochain numéro vient tracer. Vol. 4 №03 — panic/recover, la frontière. On quitte les erreurs qu'on déroule pour celles qu'on n'aurait jamais dû avoir à dérouler.And yet this volume keeps one last step. Everything we've done assumes one thing: that failure is a value — something you can return, and that the caller can choose to handle. But there are failures that aren't negotiable values: a broken invariant, a state that should never have existed, a bug of the program against itself. Faced with that, returning an error would be a polite lie — there's nothing to decide, there's only to stop. That's where the language changes register: panic isn't an exception, recover isn't a catch, and the boundary between the two worlds — the value you compose and the rupture you contain — is precisely what the next issue comes to draw. Vol. 4 №03 — panic/recover, the boundary. We leave the errors you unroll for those you should never have had to unroll.