If Go copies every argument, why can a function mutate the caller's map and slice elements?

## Two things people conflate "Go passes everything by value" and "a function can change my map" are both true, and they are only in tension if you assume a value contains all its data. Several Go types are small **handles** to larger structures, and copying a handle duplicates the handle while leaving the structure shared. ## Slices: a three-word header A slice value is a struct of three words: - a **pointer** to the first element of a backing array, - a **length** — how many elements this view exposes, - a **capacity** — how many the backing array holds from that pointer onward. Passing a `[]int` copies those three words. The pointer in the copy is the same address, so both headers view the same array: ```go func zeroFirst(s []int) { s[0] = 0 // caller sees this } ``` The write goes through the shared pointer into the shared array. But this does not: ```go func grow(s []int) { s = append(s, 1) // caller's len is unchanged either way } ``` `append` returns a new header — possibly with a new pointer, certainly with a larger `len` — and assigning it updates only the callee's copy. That is precisely why `append`'s result must be assigned back, and why functions that lengthen a slice return it (`func addItem(s []T, x T) []T`) rather than mutating the parameter. If you truly need the caller's *variable* re-pointed, take a `*[]int`; that is rare and usually a sign the return value is the better API. ## Maps and channels: handles A map value is a pointer-sized handle to the runtime's hash table. Copying it copies the handle, so: ```go func record(m map[string]int) { m["hits"]++ // caller sees this } ``` There is no separate "map object" in the caller to keep in sync — there is one table and now two handles to it. The same is true of channels: a copied channel value refers to the same channel, which is what makes `func worker(jobs <-chan Job)` work at all. Function values behave similarly — copying the value copies a pointer to code plus any captured environment. A consequence worth stating: because a map is a handle, you cannot "reset the caller's map" by assigning `m = nil` or `m = make(map[string]int)` inside the callee. That rebinds the local handle. Use `clear(m)` if you mean to empty the shared table, or return a new map. ## Interface values: a copied pair An interface value holds two words: the dynamic **type** and a pointer to (or, for pointer-shaped values, directly) the **dynamic value**. Passing an interface copies the pair. If the concrete value stored in it is a `*Player`, both copies point at the same `Player` and mutations through either are shared. If the concrete value is a `Player` struct stored by value, the interface owns its own copy and the caller's original is untouched. The interface does not change the rule — it just adds one more layer where a copy might or might not carry a pointer. ## Structs: exactly what they contain A struct copy is field by field. Fields that are `int`, `string` headers, arrays or nested structs are duplicated; fields that are pointers, slices, maps, channels or functions are duplicated *as handles*, leaving the pointed-to data shared. So: ```go type Player struct { Name string Inventory []Item // copied header, shared items Effects map[string]int // copied handle, shared table Target *Player // copied pointer, shared target } ``` Copying a `Player` gives you an independent `HP` and `Name` but an `Inventory` that aliases the original's items. That is neither a bug nor a guarantee — it is the direct consequence of what the fields are — but it is the reason "I copied the struct so it's mine now" is a dangerous sentence. ## Arrays are the counterexample `[8]int` is not a handle. It *is* the eight ints, so copying it copies all of them, and passing a large array to a function copies the whole thing on every call. That contrast — array copies wholesale, slice copies a three-word view — is the cleanest way to demonstrate that Go has one rule, not several. ## How to answer this in an interview Say the rule, then say what is inside the value. "Go copies the argument. For a slice the argument is a header containing a pointer, so the copy views the same array — element writes are shared, but the length lives in the copy." That sentence covers slices, maps, channels, interfaces and struct fields in one breath, and it is the answer that shows you understand the mechanism rather than a list of memorised exceptions.