How do you deep copy a Go struct that holds a map of slices?

## There is no deep copy in the language Go gives you exactly one copying operation - assignment - and it is one level deep. Every deep copy in a Go program is code somebody wrote. The idiomatic shape is a method: ```go func (p Policy) Clone() Policy ``` or `func (p *Policy) Clone() *Policy` when the type is normally used through a pointer. Naming it `Clone` matches the standard library's own vocabulary (`slices.Clone`, `maps.Clone`, `net/url.URL.Clone`). ## Why the standard helpers do not finish the job `slices.Clone(s)` returns a new slice whose elements are copied **by assignment**, and `maps.Clone(m)` returns a new map whose keys and values are set by ordinary assignment. Both are documented as shallow. The `copy(dst, src)` builtin is the same thing at a lower level: it copies `min(len(dst), len(src))` elements, again by assignment. So for `map[string][]string`: - `maps.Clone` gives you a genuinely new map - inserting or deleting a key no longer affects the original - but every value in it is the *same slice header* as before, so `clone["a"][0] = "x"` writes into the original's backing array One level of cloning fixes one level of sharing. A map of slices has two levels, so you need two steps. ## The shape of a correct clone ```go type Rule struct { Name string Hosts []string } type Policy struct { Rules map[string]Rule Owner *User } func (p Policy) Clone() Policy { c := p // scalars copied; Rules and Owner still shared c.Rules = make(map[string]Rule, len(p.Rules)) for k, r := range p.Rules { r.Hosts = slices.Clone(r.Hosts) // r is already a copy of the value c.Rules[k] = r } if p.Owner != nil { owner := *p.Owner c.Owner = &owner } return c } ``` Three details in that code carry the whole technique: 1. `c := p` first, so you never forget a scalar field when the struct grows. 2. The loop variable `r` is already a copy of the map value, so mutating `r.Hosts` before inserting is safe - and necessary, because map elements are not addressable and cannot be modified in place. 3. The `nil` check before dereferencing `p.Owner`; a deep copy that panics on a nil pointer field is the most common bug in hand-written clones. ## Deciding how deep "deep" goes A deep copy is not automatically the right answer for every field. Ask, per field, whether the copy is meant to be an independent value or to keep talking to the same collaborator: - data the caller may mutate: clone it - a `*log.Logger`, a `*sql.DB`, a channel, a `context.Context`: share it deliberately, do not clone it - an immutable field such as a `string` or a `time.Time`: plain assignment is already correct - a field holding a lock: a struct containing a `sync.Mutex` must not be copied at all, so a value-receiver `Clone` on such a type is itself a bug Document the answer. A `Clone` whose depth is undocumented is a trap for the next reader, who will assume it is total. ## Failure modes to watch for - **Cycles.** A hand-written recursive clone over a graph that points back at itself will recurse forever. If your data can be cyclic you need a `map[*T]*T` of already-copied nodes, which is a strong hint that a deep copy is the wrong design. - **Silent drift.** A `Clone` that lists fields explicitly (`return Policy{Rules: ..., Owner: ...}`) goes stale the moment somebody adds a field. Starting from `c := p` and overriding the reference fields keeps new scalar fields correct by default; a test that clones, mutates the source, and asserts the clone is unchanged is what catches the rest. - **Cost.** A deep copy allocates: one allocation per map and per slice, at least. On a hot path that is often more expensive than the mutation you were defending against. Measure with a benchmark using `-benchmem` before making cloning the default. - **Reflection.** A generic reflect-based deep copier looks attractive and is a poor trade: it is slow, it cannot see unexported fields in other packages, and it copies things that were meant to be shared. Hand-written clones are boring and correct. ## The short version Copy the struct, then rebuild every field that is a slice, map, pointer or nested struct containing one of those - and stop wherever sharing is intentional.