Generic Algorithms: slices, maps & cmp Packages

Go 1.21 added slices, maps, and cmp - generic-first stdlib packages for sorting, searching, cloning, and three-way comparison.

Use them before custom helpers; extend with your own generics only for domain logic they do not cover.

Summary

slices operates on []E with constraints like cmp.Ordered or comparable.

maps provides copy, delete, and equality for map[K]V.

cmp defines Ordered, Compare, and Or for building constraints and comparers.

Custom algorithms follow the same patterns: one type parameter for elements, separate parameters for keys and values when needed.

Recipe

Quick-reference recipe card - copy-paste ready.

import (
    "cmp"
    "slices"
)
 
func TopN[T cmp.Ordered](data []T, n int) []T {
    if n <= 0 {
        return nil
    }
    cp := slices.Clone(data)
    slices.Sort(cp)
    if n > len(cp) {
        n = len(cp)
    }
    return cp[len(cp)-n:]
}

When to reach for this:

• Sorting, binary search, compact, insert, delete on slices.
• Cloning or merging maps without manual loops.
• Building constraints with cmp.Ordered instead of copying large unions.

Working Example

package main
 
import (
    "cmp"
    "fmt"
    "maps"
    "slices"
)
 
type User struct {
    Name string
    Age  int
}
 
func main() {
    nums := []int{3, 1, 4, 1, 5}
    slices.Sort(nums)
    fmt.Println(nums)
    fmt.Println(slices.BinarySearch(nums, 4))
 
    m1 := map[string]int{"a": 1, "b": 2}
    m2 := maps.Clone(m1)
    m2["c"] = 3
    fmt.Println(maps.Equal(m1, m2))
 
    users := []User{{"ann", 30}, {"bob", 25}}
    slices.SortFunc(users, func(a, b User) int {
        return cmp.Compare(a.Age, b.Age)
    })
    fmt.Println(users)
}

What this demonstrates:

• slices.Sort requires ordered elements; SortFunc accepts custom comparers returning cmp sign.
• maps.Clone and maps.Equal avoid hand-rolled copy/equality.
• Struct sorting uses cmp.Compare on fields, not == on structs unless fully comparable and that is the intended order.

Deep Dive

How It Works

• Stdlib generic functions are implemented once in the library and monomorphized at your call sites.
• slices functions mutate slices in place unless the name says Clone or returns a new slice.
• maps functions do not deep-copy values; pointers and slices inside values alias like ordinary map assignment.
• cmp.Compare returns -1, 0, or 1 for ordered types and is the preferred comparer return type for slices.SortFunc.

slices Highlights

maps Highlights

cmp Highlights

Go Notes

// Multi-key sort with cmp.Or
slices.SortFunc(records, func(a, b Record) int {
    return cmp.Or(
        cmp.Compare(a.Region, b.Region),
        cmp.Compare(a.Name, b.Name),
    )
})

• Prefer slices.SortFunc over sort.Slice for new code - clearer comparer signatures.
• For stable sort requirements, check whether slices.SortStableFunc fits your Go version and use it when equal elements must keep input order.
• Custom generic Map transforms are still useful: func Map[T, U any](in []T, f func(T) U) []U.

Gotchas

• Sorting with == on structs - Use SortFunc with explicit field order. Fix: cmp.Or on fields.
• Assuming maps.Clone deep-copies - Values alias. Fix: clone nested structures explicitly when needed.
• Binary search on unsorted slice - Undefined position results. Fix: sort first or document precondition.
• Reusing union constraints locally - Drift from stdlib. Fix: import cmp.Ordered.
• Mutating slice during range in custom algorithm - Skips elements or races. Fix: index-based loops or collect indices first.
• Passing nil map to maps.Copy - Panic on write to nil map. Fix: dst = make(map[K]V) before copy.

Alternatives

FAQs

Related

• Generics Basics - slices.Contains intro
• Type Parameters & Constraint Interfaces - cmp.Ordered definition
• Type Sets & the comparable Constraint - maps.Equal vs ==
• Generic Data Structures: Sets, Queues, Maps - containers using these helpers
• Performance Implications of Generics - sort cost and inlining

Stack versions: This page was written for Go 1.26.x (Green Tea GC default, go fix modernizers - verify patch at build), chi (latest - verify at build), gin (latest - verify at build), echo (latest - verify at build), google.golang.org/grpc (latest - verify at build), sigs.k8s.io/controller-runtime (latest - verify at build), kubebuilder (latest - verify at build), tinygo (latest - verify board targets at build), wazero (latest - verify at build), and golangci-lint (latest - verify linter set at build).