golang-data-structures

Use make([]T, 0, n) for slices and make(map[K]V, n) for maps when the size is known or estimable. Preallocation avoids repeated backing-array copies during slice growth and rehashing during map population. Go 1.21+ also offers slices.Grow for pre-growing before bulk appends.

Use strings.Builder for pure string concatenation because String() returns the result without copying. Use bytes.Buffer when you need io.Reader/io.Writer behavior or byte manipulation. Both support Grow(n) for preallocation.

Go maps never shrink their bucket array; delete() removes entries but the allocated buckets are retained. The only fix is rebuilding: create a fresh map with make and copy surviving entries, or set the map to nil and reassign so the GC can reclaim it.

Use container/list only when you need O(1) insertion or removal at arbitrary positions via element references, such as LRU caches. Slices outperform linked lists for most cases due to cache locality, since each list node is a separate heap allocation.

weak.Pointer[T] (Go 1.24+) holds a reference without preventing garbage collection; Value() returns nil after the object is collected. Use it for caches and canonicalization maps, paired with runtime.AddCleanup instead of the more error-prone runtime.SetFinalizer.

Avoid generics when the constraint is just any (it adds syntax over interface{} with no benefit), when only one or two instantiations exist, or when constraints become convoluted. Generics shine for containers, algorithms, and utilities where logic is identical across types.