Le receveur, valeur ou pointeur The receiver, value or pointer

func (t T) ou func (t *T) ? Le receveur valeur travaille sur une copie et ne mute rien ; le receveur pointeur mute l'original. Le choix décide aussi du jeu de méthodes — et de ce qui satisfait une interface. func (t T) or func (t *T)? A value receiver works on a copy and mutates nothing; a pointer receiver mutates the original. The choice also decides the method set — and what satisfies an interface.

Audience
Dev qui voit « does not implement, method has pointer receiver » et ne comprend pas pourquoi Dev who sees 'does not implement, method has pointer receiver' and can't see why
ChapitresChapters
5
LectureReading
≈ 16 min
NiveauLevel
●●○○
Date
Oct 2027 Oct 2027

ReceveurMéthodesPointeur

SommaireContents ·
№ 01CadrageFraming3 min

Une méthode est une fonction avec un receveur. Et ce receveur obéit, lui aussi, à la règle : T est copié, *T ne l'est pas.A method is a function with a receiver. And that receiver, too, obeys the rule: T is copied, *T is not.

Le numéro précédent a posé la sémantique de valeur fonction par fonction : passer une struct, c'est en passer une copie, et il faut un pointeur pour muter l'original. Une méthode n'échappe pas à cette règle — elle ne fait que la déplacer dans un endroit particulier de la signature : le receveur, ce petit paramètre placé avant le nom de la méthode. Quand tu écris func (c Counter) Foo(), le receveur c est une valeur, donc une copie de l'appelant, exactement comme un argument passé par valeur. Quand tu écris func (c *Counter) Foo(), le receveur est un pointeur, donc l'adresse de l'appelant, et la méthode travaille sur l'original. Tout ce qu'on a appris au numéro 1 s'applique tel quel : le receveur valeur protège mais ne mute pas ; le receveur pointeur mute mais expose l'original. La nouveauté, c'est que ce choix n'est plus pris au cas par cas, à chaque appel — il est gravé une fois pour toutes dans la déclaration de la méthode. Tu décides, en écrivant la méthode, si elle verra une copie ou l'original, pour tous ses appelants présents et futurs. Et cette décision, anodine en apparence, a une conséquence que le numéro 1 n'avait pas : elle façonne ce qu'on appelle le jeu de méthodes du type, et donc ce qui pourra, ou non, satisfaire une interface. C'est le fil qu'on déroule jusqu'au chapitre 4.The previous issue laid down value semantics function by function: passing a struct passes a copy of it, and you need a pointer to mutate the original. A method doesn't escape this rule — it merely moves it to a particular spot in the signature: the receiver, that little parameter placed before the method's name. When you write func (c Counter) Foo(), the receiver c is a value, hence a copy of the caller, exactly like an argument passed by value. When you write func (c *Counter) Foo(), the receiver is a pointer, hence the caller's address, and the method works on the original. Everything we learned in issue 1 applies as is: the value receiver protects but doesn't mutate; the pointer receiver mutates but exposes the original. What's new is that this choice is no longer made case by case, at each call — it's carved once and for all into the method's declaration. You decide, when writing the method, whether it will see a copy or the original, for all its present and future callers. And this decision, seemingly trivial, has a consequence issue 1 didn't: it shapes what's called the type's method set, and thus what can, or cannot, satisfy an interface. That's the thread we unwind through to chapter 4.

Le même type, deux receveurs, deux intentionsThe same type, two receivers, two intents
type Counter struct{ n int }

// receveur VALEUR : c est une copie de l'appelant
func (c Counter) Value() int { return c.n }   // lit, ne mute rien

// receveur POINTEUR : c est l'adresse de l'appelant
func (c *Counter) Inc()      { c.n++ }         // mute l'original

c := Counter{}
c.Inc()                 // … c.n devient 1 (Go prend &c automatiquement)
fmt.Println(c.Value())  // 1
Le receveur, c'est l'argument du numéro 1 déplacéThe receiver is issue 1's argument, relocated
func (c T)
receveur valeur
c est une copie · lit l'état · ne mute jamais l'original
|
func (c *T)
receveur pointeur
c est l'adresse · mute l'original · partage l'état

Choisir le receveur, c'est répondre une fois à la question du volume : cette méthode travaille-t-elle sur une copie, ou sur l'original ? La réponse vaut pour tous les appels — et, on le verra, décide aussi de qui peut appeler quoi.Choosing the receiver is answering, once, the volume's question: does this method work on a copy, or on the original? The answer holds for all calls — and, as we'll see, also decides who can call what.

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

« Cette méthode doit-elle changer l'état du type ? si oui, receveur pointeur ; sinon, valeur — et je reste cohérent sur tout le type. » La règle de cohérence est aussi importante que le choix lui-même : si une seule méthode a besoin d'un pointeur, on met toutes les méthodes du type en pointeur, pour ne pas se retrouver avec un jeu de méthodes bancal. Le chapitre 4 montrera ce que « bancal » coûte, exactement."Does this method need to change the type's state? if yes, pointer receiver; if not, value — and I stay consistent across the whole type." The consistency rule matters as much as the choice itself: if a single method needs a pointer, you make all the type's methods pointer receivers, to avoid ending up with a lopsided method set. Chapter 4 will show what "lopsided" costs, exactly.

Pourquoi c.Inc() marche sans écrire (&c).Inc()Why c.Inc() works without writing (&c).Inc()

Tu remarqueras que, dans l'exemple, on appelle c.Inc() directement, alors qu'Inc a un receveur pointeur et que c est une valeur. Go insère automatiquement le &c pour toi, à condition que c soit adressable — c'est-à-dire qu'il ait une adresse en mémoire, ce qui est le cas d'une variable locale. À l'inverse, l'appel inverse marche aussi : sur un pointeur p, p.Value() équivaut à (*p).Value(). Ce sucre syntaxique masque la mécanique au quotidien et rend le code lisible. Mais il a des limites — certaines valeurs ne sont pas adressables — et c'est précisément là que le jeu de méthodes cesse d'être une abstraction théorique pour devenir une erreur de compilation concrète. On y arrive au chapitre 3.You'll notice that, in the example, we call c.Inc() directly, even though Inc has a pointer receiver and c is a value. Go automatically inserts the &c for you, provided c is addressable — that is, has an address in memory, which a local variable does. Conversely, the reverse call also works: on a pointer p, p.Value() is equivalent to (*p).Value(). This syntactic sugar hides the mechanics day to day and keeps code readable. But it has limits — some values aren't addressable — and that's precisely where the method set stops being a theoretical abstraction and becomes a concrete compile error. We get there in chapter 3.

№ 02La surpriseThe surprise4 min

Une méthode à receveur valeur qui prétend muter ne mute rien. Et cette fois, l'appel ne montre aucun indice.A value-receiver method that claims to mutate, mutates nothing. And this time, the call site shows no hint.

On retrouve ici, presque mot pour mot, la surprise du numéro 1 — une mutation qui ne prend pas — mais sous une forme plus sournoise, parce qu'elle est invisible à l'appel. Une méthode Inc à receveur valeur reçoit une copie du Counter, l'incrémente, et jette cette copie au retour ; l'original ne bouge jamais. Le code de la méthode est juste, la logique est juste, et pourtant le compteur reste à zéro après trois appels. Ce qui rend le bug particulièrement traître, c'est le site d'appel : c.Inc() s'écrit exactement de la même façon, que le receveur soit une valeur ou un pointeur. Au numéro 1, le piège se voyait — il fallait écrire deposit(a, ...) sans le &, et le & manquant était un indice visible. Ici, le choix valeur/pointeur est enfoui dans la déclaration de la méthode, parfois dans un autre fichier ; rien, sur la ligne c.Inc(), ne dit si l'appel mute ou non. Tu dois aller lire la signature de la méthode pour le savoir. C'est pourquoi la convention compte tant : une méthode qui modifie l'état doit avoir un receveur pointeur, point. Et si tu hésites — si tu écris une méthode qui « pourrait » muter un jour — prends le pointeur dès le départ, car corriger après coup t'oblige à toucher toutes les méthodes du type d'un coup, pour rester cohérent.We find here, almost word for word, issue 1's surprise — a mutation that doesn't take — but in a sneakier form, because it's invisible at the call. A value-receiver Inc method receives a copy of the Counter, increments it, and discards that copy on return; the original never moves. The method's code is right, the logic is right, and yet the counter stays at zero after three calls. What makes the bug particularly treacherous is the call site: c.Inc() is written exactly the same way, whether the receiver is a value or a pointer. In issue 1, the trap was visible — you had to write deposit(a, ...) without the &, and the missing & was a visible clue. Here, the value/pointer choice is buried in the method's declaration, sometimes in another file; nothing, on the line c.Inc(), says whether the call mutates or not. You have to go read the method's signature to know. That's why the convention matters so much: a method that modifies state must have a pointer receiver, period. And if you hesitate — if you write a method that 'might' mutate one day — take the pointer from the start, because fixing it after the fact forces you to touch all the type's methods at once, to stay consistent.

Receveur valeur : chaque Inc mute une copie jetableValue receiver: each Inc mutates a throwaway copy
type Counter struct{ n int }

func (c Counter) Inc() { c.n++ }   // c est une COPIE : ++ meurt au retour

c := Counter{}
c.Inc()
c.Inc()
c.Inc()
fmt.Println(c.n)   // 0  ← trois incréments perdus, aucun avertissement

À chaque c.Inc(), Go copie c dans le receveur, incrémente cette copie, et la détruit en sortant. L'original ne reçoit jamais rien. Le plus dur est de repérer la cause : la ligne d'appel est irréprochable, le corps de Inc aussi. Le bug n'est ni à l'appel ni dans le calcul — il est dans un seul caractère absent de la signature, l'étoile manquante devant Counter. C'est le genre d'erreur qu'on ne voit qu'en se forçant à lire la déclaration du receveur.On each c.Inc(), Go copies c into the receiver, increments that copy, and destroys it on exit. The original never receives anything. The hardest part is spotting the cause: the call line is impeccable, the body of Inc too. The bug is neither at the call nor in the computation — it's in a single character absent from the signature, the missing star before Counter. It's the kind of error you only see by forcing yourself to read the receiver's declaration.

Le même piège qu'au numéro 1, mais caché plus loinThe same trap as issue 1, but hidden further

Au numéro 1, le choix valeur/pointeur se lisait à l'appel, dans le & que tu écrivais ou non. Avec une méthode, le choix migre dans la déclaration et disparaît du site d'appel : c.Inc() est identique des deux côtés. C'est le prix du confort — Go t'épargne d'écrire (&c).Inc() — mais ça déplace la responsabilité vers l'auteur de la méthode. D'où la seule discipline qui tienne : décide du receveur en fonction de l'intention (muter ou non), garde-le cohérent sur tout le type, et considère qu'une méthode à receveur valeur est une promesse de ne rien changer.In issue 1, the value/pointer choice read at the call site, in the & you wrote or didn't. With a method, the choice migrates into the declaration and vanishes from the call site: c.Inc() is identical on both sides. It's the price of convenience — Go spares you writing (&c).Inc() — but it shifts responsibility to the method's author. Hence the only discipline that holds: decide the receiver by intent (mutate or not), keep it consistent across the whole type, and treat a value-receiver method as a promise to change nothing.

Le site d'appel ne te dira pas si la méthode mute. Seul le receveur le dit — une étoile, ou rien.The call site won't tell you whether the method mutates. Only the receiver tells you — a star, or nothing.
№ 03La mécaniqueThe mechanics5 min

Les méthodes à receveur pointeur n'appartiennent qu'à *T. Celles à receveur valeur, à T et *T.Pointer-receiver methods belong only to *T. Value-receiver ones, to T and *T.

Pour comprendre la portée réelle du choix de receveur, il faut introduire une notion précise : le jeu de méthodes d'un type, c'est-à-dire l'ensemble des méthodes qu'on peut appeler sur lui. Et la règle est asymétrique. Les méthodes à receveur valeur appartiennent à la fois au jeu de T et à celui de *T : depuis une valeur comme depuis un pointeur, on peut les appeler, car on peut toujours obtenir une copie. Les méthodes à receveur pointeur, elles, n'appartiennent qu'au jeu de *T : pour les appeler, il faut une adresse, et une valeur quelconque n'en a pas toujours une. Au quotidien, Go masque cette asymétrie grâce à un sucre : quand tu appelles une méthode pointeur sur une variable adressable, il prend l'adresse pour toi. C'est pour ça que c.Inc() marche sur une variable locale, même si Inc a un receveur pointeur — Go réécrit silencieusement en (&c).Inc(). Mais ce sucre a une frontière nette : il ne fonctionne que sur les valeurs adressables. Un élément de map, le résultat d'un appel de fonction, une constante : ces valeurs n'ont pas d'adresse stable, et Go refuse alors d'appeler une méthode pointeur sur elles. Surtout — et c'est le point qui compte pour la suite — le jeu de méthodes formel de T ne contient pas les méthodes pointeur, sucre ou pas. Cette commodité d'appel et l'appartenance au jeu de méthodes sont deux choses distinctes. La première rend le code agréable ; la seconde décide de ce qui satisfait une interface. Le chapitre 4 montre ce qui se passe quand on confond les deux.To grasp the real reach of the receiver choice, we need a precise notion: a type's method set, that is, the set of methods you can call on it. And the rule is asymmetric. Value-receiver methods belong to both T's set and *T's: from a value as from a pointer, you can call them, since you can always obtain a copy. Pointer-receiver methods, by contrast, belong only to *T's set: to call them, you need an address, and an arbitrary value doesn't always have one. Day to day, Go hides this asymmetry with a sugar: when you call a pointer method on an addressable variable, it takes the address for you. That's why c.Inc() works on a local variable, even though Inc has a pointer receiver — Go silently rewrites it as (&c).Inc(). But this sugar has a sharp boundary: it only works on addressable values. A map element, a function call's result, a constant: these values have no stable address, and Go then refuses to call a pointer method on them. Above all — and this is the point that matters for what follows — T's formal method set does not contain the pointer methods, sugar or no sugar. This call convenience and method-set membership are two distinct things. The first makes code pleasant; the second decides what satisfies an interface. Chapter 4 shows what happens when you conflate the two.

Adressable : Go prend l'adresse pour toiAddressable: Go takes the address for you
type Counter struct{ n int }
func (c *Counter) Inc() { c.n++ }   // receveur pointeur

c := Counter{}       // variable locale : ADRESSABLE
c.Inc()              // Go réécrit en (&c).Inc() — OK

p := &Counter{}      // déjà un pointeur
p.Inc()              // OK, évidemment

Une variable locale a une adresse, donc Go peut la prendre automatiquement : c.Inc() devient (&c).Inc() sans que tu l'écrives. C'est le cas le plus courant, et il donne l'illusion que « les méthodes pointeur marchent sur les valeurs ». Elles marchent — quand la valeur est adressable. Cette nuance reste invisible tant qu'on manipule des variables ; elle surgit dès qu'on touche une valeur sans adresse stable.A local variable has an address, so Go can take it automatically: c.Inc() becomes (&c).Inc() without you writing it. It's the most common case, and it gives the illusion that "pointer methods work on values." They do — when the value is addressable. This nuance stays invisible as long as you handle variables; it surfaces the moment you touch a value with no stable address.

Le jeu de méthodes : la commodité d'appel n'est pas l'appartenanceThe method set: call convenience isn't membership
type T struct{}
func (t T)  Read()  {}   // receveur valeur
func (t *T) Write() {}   // receveur pointeur

// jeu de méthodes de   T  :  { Read }            ← Write est ABSENT
// jeu de méthodes de  *T  :  { Read, Write }     ← les deux présentes

// t.Write() compile quand t est adressable (Go prend &t pour toi).
// mais le JEU de méthodes de T, lui, ne contient pas Write —
// et c'est ce jeu, pas la commodité d'appel, qui décide des interfaces.

Voilà le cœur de la mécanique, et la marche du chapitre 4. Write, à receveur pointeur, n'est pas dans le jeu de méthodes de T — seulement dans celui de *T. Que t.Write() compile sur une variable adressable est une commodité du compilateur, pas une appartenance au jeu de T. Et quand on demandera « ce type satisfait-il telle interface ? », c'est le jeu de méthodes formel qui répondra, pas le sucre syntaxique. Retiens la table : receveur valeur → dans les deux jeux ; receveur pointeur → dans *T seulement.Here's the core of the mechanics, and the step to chapter 4. Write, with a pointer receiver, is not in T's method set — only in *T's. That t.Write() compiles on an addressable variable is a compiler convenience, not membership in T's set. And when we ask "does this type satisfy that interface?", it's the formal method set that answers, not the syntactic sugar. Remember the table: value receiver → in both sets; pointer receiver → in *T only.

Que t.Write() compile ne veut pas dire que Write appartient à T. Le jeu de méthodes, lui, ne pardonne pas — et c'est lui qui décide des interfaces.That t.Write() compiles doesn't mean Write belongs to T. The method set, though, doesn't forgive — and it's what decides interfaces.
№ 04Le piègeThe trap4 min

« User does not implement Stringer » — alors que la méthode existe. Le receveur pointeur en a décidé."User does not implement Stringer" — though the method exists. The pointer receiver decided so.

C'est ici que le choix du receveur cesse d'être une affaire de mutation pour devenir une affaire d'identité de type — et c'est l'une des erreurs les plus déroutantes de Go. Au volume 3, on a vu qu'un type satisfait une interface dès qu'il en possède toutes les méthodes, implicitement, sans mot-clé. Ce qu'on n'avait pas encore les outils pour dire, c'est : possède selon quel jeu de méthodes ? Et la réponse, on la tient depuis le chapitre 3. Si String a un receveur pointeur, il n'appartient qu'au jeu de méthodes de *User, pas à celui de User. Donc *User satisfait Stringer, mais User ne le satisfait pas — bien que, à l'œil, « le type a la méthode ». Le compilateur le dit sans détour : User does not implement Stringer (method String has pointer receiver). Le message est précis, mais il surprend toujours, parce qu'on a écrit la méthode et qu'on la voit. Le piège est d'autant plus vicieux que le sucre syntaxique du chapitre 3 fonctionne ailleurs : tu peux appeler u.String() sur une variable User sans problème, ce qui renforce l'illusion que User « a » la méthode. Mais l'affectation à une interface, elle, exige l'appartenance formelle au jeu de méthodes — et là, le sucre ne s'applique pas, car la valeur stockée dans l'interface n'est plus adressable. Conclusion pratique : si un type doit satisfaire une interface via ses pointeurs, range des pointeurs ; et choisis tes receveurs de façon cohérente, pour que le type entier soit utilisable d'une seule manière, sans surprise.Here's where the receiver choice stops being about mutation and becomes about type identity — and it's one of Go's most disorienting errors. In volume 3, we saw that a type satisfies an interface as soon as it has all its methods, implicitly, with no keyword. What we didn't yet have the tools to say is: has them according to which method set? And the answer, we've held since chapter 3. If String has a pointer receiver, it belongs only to *User's method set, not to User's. So *User satisfies Stringer, but User does not — even though, to the eye, 'the type has the method.' The compiler says it plainly: User does not implement Stringer (method String has pointer receiver). The message is precise, but it always surprises, because you wrote the method and you can see it. The trap is all the more vicious because chapter 3's syntactic sugar works elsewhere: you can call u.String() on a User variable with no problem, which reinforces the illusion that User 'has' the method. But assignment to an interface requires formal membership in the method set — and there, the sugar doesn't apply, because the value stored in the interface is no longer addressable. Practical conclusion: if a type must satisfy an interface through its pointers, store pointers; and choose your receivers consistently, so the whole type is usable one single way, without surprise.

Méthode à receveur pointeur : seul *User implémentePointer-receiver method: only *User implements
type Stringer interface{ String() string }

type User struct{ Name string }
func (u *User) String() string { return u.Name }  // receveur POINTEUR

var s Stringer = User{"alice"}    // ERREUR de compilation :
//   cannot use User{…} (value of type User) as Stringer:
//   User does not implement Stringer (method String has pointer receiver)

var s Stringer = &User{"alice"}   // OK : *User a String dans son jeu

La valeur User est refusée, le pointeur &User est accepté — toute la différence tient au jeu de méthodes. C'est la source numéro un des « does not implement » qu'on ne comprend pas. On l'a souvent dans une slice de Stringer : y ranger une valeur User échoue, y ranger un &User passe. La leçon du volume 3 — satisfaction implicite — était juste ; il lui manquait cette précision : implicite, oui, mais sur le bon jeu de méthodes.The User value is refused, the pointer &User accepted — the whole difference lies in the method set. It's the number-one source of the "does not implement" you can't make sense of. You often hit it in a slice of Stringer: putting a User value in it fails, putting a &User in it passes. Volume 3's lesson — implicit satisfaction — was right; it just lacked this precision: implicit, yes, but over the right method set.

La cohérence n'est pas un luxeConsistency isn't a luxury

Mélanger receveurs valeur et pointeur sur un même type, c'est se condamner à des bugs intermittents. Une moitié des méthodes mute l'original, l'autre une copie ; le type satisfait une interface par son pointeur mais pas par sa valeur ; et le lecteur doit vérifier chaque signature. La convention Go est nette : choisis un camp pour tout le type. Dès qu'une seule méthode a besoin d'un pointeur — pour muter, ou parce qu'un champ l'exige — passe tout le type en receveurs pointeur. Le type devient alors « un type pointeur », qu'on stocke et qu'on passe par *T, sans plus jamais se poser la question.Mixing value and pointer receivers on one type is condemning yourself to intermittent bugs. Half the methods mutate the original, the other a copy; the type satisfies an interface through its pointer but not its value; and the reader must check every signature. The Go convention is clear: pick a side for the whole type. The moment a single method needs a pointer — to mutate, or because a field demands it — switch the whole type to pointer receivers. The type then becomes "a pointer type," stored and passed as *T, never questioned again.

Parfois le pointeur n'est pas un choix, mais une obligation.Sometimes the pointer isn't a choice, but an obligation.

Jusqu'ici, valeur ou pointeur restait une décision : on pesait mutation, taille, satisfaction d'interface, et on tranchait. Le prochain numéro présente des types pour lesquels la question ne se pose plus, parce que les copier les casse. Un sync.Mutex copié, c'est un verrou dupliqué dans un état incohérent ; un sync.WaitGroup copié, c'est un compteur qui se dédouble. Ces types ne survivent pas à une copie, et donc leurs méthodes doivent avoir des receveurs pointeur — non plus par préférence, mais par nécessité. Mieux : go vet possède une règle, copylocks, qui refuse de te laisser les copier. La sémantique de valeur, qu'on a apprise à manier, rencontre ici sa contre-indication formelle. Vol. 6 №03 — La copie qui casse.So far, value or pointer stayed a decision: you weighed mutation, size, interface satisfaction, and you ruled. The next issue presents types for which the question no longer arises, because copying them breaks them. A copied sync.Mutex is a lock duplicated in an inconsistent state; a copied sync.WaitGroup is a counter that splits in two. These types don't survive a copy, so their methods must have pointer receivers — no longer by preference, but by necessity. Better: go vet has a rule, copylocks, that refuses to let you copy them. Value semantics, which we've learned to wield, meets here its formal contraindication. Vol. 6 №03 — The copy that breaks.

« La méthode existe » ne suffit pas. Elle doit exister dans le bon jeu de méthodes — et le receveur en décide."The method exists" isn't enough. It must exist in the right method set — and the receiver decides that.
№ 05Bilan & éditoWrap-up & editorial2 min

Le receveur décide trois choses d'un coup : qui est muté, ce qu'on peut appeler, et ce qui satisfait une interface.The receiver decides three things at once: who gets mutated, what you can call, and what satisfies an interface.

Ce numéro a montré qu'un receveur n'est rien d'autre que l'argument du numéro 1, déplacé dans la signature de la méthode et figé à la déclaration. Receveur valeur : la méthode travaille sur une copie, ne mute rien, et entre dans le jeu de méthodes de T comme de *T. Receveur pointeur : la méthode travaille sur l'original, peut le muter, mais n'entre que dans le jeu de *T. La surprise — une méthode qui « mute » sans effet — est le piège du numéro 1 caché plus loin, dans la déclaration plutôt qu'à l'appel. La mécanique a introduit le jeu de méthodes et son sucre : Go prend l'adresse pour toi sur une valeur adressable, mais ce confort n'est pas l'appartenance formelle, et il s'arrête net sur un élément de map ou un retour de fonction. Le piège, enfin, ramène au volume 3 : c'est le jeu de méthodes, pas la commodité d'appel, qui décide de la satisfaction d'interface — d'où le « does not implement, method has pointer receiver » qui déconcerte tant. La règle qui clôt le numéro tient en une phrase : choisis ton receveur par l'intention, et garde-le cohérent sur tout le type. Le prochain numéro montre des types où ce choix n'en est plus un.This issue showed that a receiver is nothing but issue 1's argument, moved into the method's signature and frozen at the declaration. Value receiver: the method works on a copy, mutates nothing, and enters T's method set as well as *T's. Pointer receiver: the method works on the original, can mutate it, but enters only *T's set. The surprise — a method that 'mutates' with no effect — is issue 1's trap hidden further, in the declaration rather than at the call. The mechanics introduced the method set and its sugar: Go takes the address for you on an addressable value, but that convenience isn't formal membership, and it stops dead on a map element or a function return. The trap, finally, brings us back to volume 3: it's the method set, not call convenience, that decides interface satisfaction — hence the 'does not implement, method has pointer receiver' that so disconcerts. The rule closing the issue fits in one sentence: choose your receiver by intent, and keep it consistent across the whole type. The next issue shows types where this choice is no longer one.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
Receveur valeurValue receiverfunc (t T) : copie, ne mute pas ; dans le jeu de T et de *T.func (t T): copy, no mutation; in T's set and *T's.Tu crois muter l'état, tu mutes une copie jetable.You think you mutate state, you mutate a throwaway copy.
Receveur pointeurPointer receiverfunc (t *T) : mute l'original ; dans le jeu de *T seulement.func (t *T): mutates the original; in *T's set only.La valeur ne satisfait plus l'interface ; seul le pointeur le fait.The value no longer satisfies the interface; only the pointer does.
Le sucre d'appelThe call sugarGo prend &t pour toi — mais seulement si t est adressable.Go takes &t for you — but only if t is addressable.Appel refusé sur un élément de map ou un retour de fonction.Call refused on a map element or a function return.
La cohérenceConsistencyUn seul camp pour tout le type ; un pointeur suffit à tout basculer.One camp for the whole type; one pointer is enough to switch it all.Un type bancal : mutations partielles, interface à moitié satisfaite.A lopsided type: partial mutations, half-satisfied interface.
Le numéro 1 t'a appris à choisir valeur ou pointeur à chaque appel. Celui-ci grave ce choix dans le type — et en fait dépendre tes interfaces.Issue 1 taught you to choose value or pointer at each call. This one carves that choice into the type — and makes your interfaces depend on it.
Mot de l'éditeurFrom the editor

Le receveur n'est pas une décoration syntaxique. C'est l'endroit où tu déclares si ton type est une valeur ou une identité.The receiver isn't syntactic decoration. It's where you declare whether your type is a value or an identity.

Derrière le choix valeur/pointeur se cache une question de nature. Certains types sont des valeurs : un point, une date, une somme d'argent. On les compare, on les copie, on les passe sans y penser, et deux exemplaires égaux sont interchangeables — l'identité n'a pas de sens pour eux. D'autres types sont des identités : un compteur, une connexion, un cache. Il n'en existe qu'un, on le mute, et le copier n'a pas de sens — la copie serait un second objet, distinct, qui divergerait. Le receveur est l'endroit où tu déclares laquelle de ces deux natures ton type possède. Receveur valeur, tu dis « ceci est une valeur, copiez-la librement ». Receveur pointeur, tu dis « ceci a une identité, manipulez l'original ». Tout le reste — la mutation, le jeu de méthodes, la satisfaction d'interface — découle de cette déclaration de nature. C'est pourquoi mélanger les deux trahit une indécision sur ce qu'est, au fond, le type qu'on écrit.Behind the value/pointer choice hides a question of nature. Some types are values: a point, a date, a sum of money. You compare them, copy them, pass them without thinking, and two equal instances are interchangeable — identity makes no sense for them. Other types are identities: a counter, a connection, a cache. There's only one, you mutate it, and copying it makes no sense — the copy would be a second, distinct object that would diverge. The receiver is where you declare which of these two natures your type has. Value receiver, you say 'this is a value, copy it freely.' Pointer receiver, you say 'this has an identity, handle the original.' Everything else — mutation, method set, interface satisfaction — flows from that declaration of nature. That's why mixing the two betrays an indecision about what, at heart, the type you're writing is.

Le prochain numéro pousse cette idée à sa limite, là où elle cesse d'être un choix de conception pour devenir une contrainte dure du langage. Il existe des types pour lesquels « copiez-la librement » est non seulement faux, mais dangereux : ceux qui contiennent un verrou. Un sync.Mutex tient un état — pris ou libre, avec une file d'attente — et copier cet état au milieu d'un verrouillage produit deux verrous désynchronisés, dont la protection ne protège plus rien. Le go vet du langage embarque une analyse, copylocks, dont l'unique mission est de t'interdire ces copies. C'est l'aboutissement logique de tout le volume : on a appris que tout est copié, que le receveur déclare la nature d'un type, et l'on découvre maintenant les types dont la nature interdit formellement la copie. La sémantique de valeur, omniprésente et bienveillante, a une zone rouge — et c'est là qu'on termine. Vol. 6 №03 — La copie qui casse.The next issue pushes this idea to its limit, where it stops being a design choice and becomes a hard constraint of the language. There are types for which 'copy it freely' is not only wrong, but dangerous: those holding a lock. A sync.Mutex carries a state — held or free, with a waiting queue — and copying that state mid-lock produces two desynchronized locks, whose protection no longer protects anything. The language's go vet ships an analysis, copylocks, whose sole mission is to forbid you these copies. It's the logical culmination of the whole volume: we learned that everything is copied, that the receiver declares a type's nature, and we now discover the types whose nature formally forbids the copy. Value semantics, omnipresent and benevolent, has a red zone — and that's where we end. Vol. 6 №03 — The copy that breaks.