In Go's `maps` package, when do you use `maps.Insert` instead of `maps.Collect`?

## The two collectors on the map side Go 1.23 gave the `maps` package two ways to turn an `iter.Seq2[K, V]` — a sequence of key/value pairs — back into a map: ```go func Collect[K comparable, V any](seq iter.Seq2[K, V]) map[K]V func Insert[Map ~map[K]V, K comparable, V any](m Map, seq iter.Seq2[K, V]) ``` The difference is ownership of the destination. `Collect` creates the map itself and hands it back. `Insert` is handed a map and mutates it in place; it has **no return value**, which is the first thing to remember, because writing `m = maps.Insert(m, seq)` will not compile. Mentally, `Collect` is to `Insert` what `slices.Collect` is to `slices.AppendSeq`: one allocates a fresh container, the other adds to a container you supply. ## When Insert is the right call **Merging.** A single `Collect` consumes exactly one sequence. To fold several sequences into one map you make the map once and `Insert` repeatedly: ```go merged := make(map[string]int, len(base)+len(overrides)) maps.Insert(merged, maps.All(base)) maps.Insert(merged, maps.All(overrides)) // overrides win on collisions ``` That also makes the precedence explicit and readable: later inserts overwrite earlier ones. **Pre-sizing.** `make(map[K]V, n)` reserves space for roughly `n` entries so the map does not rehash repeatedly as it fills. `Collect` cannot do that for you — a sequence has no length, so the helper has nothing to size from. If you know the count up front and it is large, making the map yourself and calling `Insert` is measurably cheaper. **Adding to something that already exists.** A cache, a registry, a read model that is being topped up — anywhere the destination map has entries you must not throw away. **A named map type.** `Insert` is constrained as `Map ~map[K]V`, so it accepts `type Counts map[string]int` and writes into it as that type. `Collect` returns the plain `map[K]V`, which you would then have to convert. ## The semantics that get asked about **Duplicate keys.** Neither helper deduplicates or errors. Both do the equivalent of `m[k] = v` for every pair, so if a sequence yields the same key twice, the map holds the value from the *last* pair yielded. If you need first-wins, check with `if _, ok := m[k]; !ok` in a hand-written loop instead. **A nil map.** Reading a nil map is fine, but writing to one panics. `maps.Insert` writes, so `var m map[string]int; maps.Insert(m, seq)` panics as soon as the sequence yields its first pair. It does not panic on an empty sequence, because no assignment ever happens — which makes this a lurking bug that only fires with real data. `maps.Collect` is immune: it makes the map itself. **Order.** A sequence has an order; a map does not. Collecting or inserting throws that order away, which is exactly why `maps.Collect(slices.All(s))` gives you a `map[int]E` keyed by the original positions — the index is preserved as data, not as layout. **Cost.** Both are O(n) in the number of pairs and both fully drain the sequence, so neither is lazy. If the sequence is unbounded, both will keep going until memory runs out. ## Choosing between them in review Reach for `Collect` when the map is a fresh result of the expression and nothing else will be added to it — it reads cleanly as one expression and there is no destination to get wrong. Reach for `Insert` the moment there are two sources, an existing destination, a known size, or a named map type. If you see `merged := maps.Collect(a)` followed by a hand-written loop copying `b` into it, that loop is an `Insert` call.