go-modern

Modern Go (1.21–1.24)

Go 1.21 — stdlib Packages

import ("slices"; "maps"; "cmp")

slices.Sort(items)
slices.SortFunc(items, func(a, b Item) int { return cmp.Compare(a.Name, b.Name) })
slices.Contains(items, item)
slices.Reverse(items)
slices.Compact(items)    // remove consecutive dupes
cloned := slices.Clone(items)

cloned := maps.Clone(m)
maps.Copy(dst, src)
maps.Equal(a, b)

cmp.Compare(a, b)       // -1, 0, 1
cmp.Or(a, b, fallback)  // first non-zero (Go 1.22)

clear(myMap)             // keeps capacity
x := min(a, b)
y := max(a, b, c)

Go 1.22

// Range over integers
for i := range 10 { process(i) }

// Loop variable fix — each iteration has its own variable
for _, item := range items {
    go func() { use(item) }() // safe, no capture needed
}

// New http.ServeMux with method routing + path params
mux := http.NewServeMux()
mux.HandleFunc("GET /api/users/{id}", func(w http.ResponseWriter, r *http.Request) {
    id := r.PathValue("id")
})

Go 1.23

// Range over functions (iterators)
func Backwards[E any](s []E) func(yield func(int, E) bool) {
    return func(yield func(int, E) bool) {
        for i := len(s) - 1; i >= 0; i-- {
            if !yield(i, s[i]) { return }
        }
    }
}
for i, v := range Backwards(items) { /* ... */ }

// Collecting iterators
keys := slices.Collect(maps.Keys(m))
sorted := slices.Sorted(maps.Keys(m))

// unique package — interned comparable handles
handle := unique.Make("hello")

Go 1.24

// Generic type aliases
type Set[T comparable] = map[T]struct{}

// testing/synctest — deterministic concurrency testing
synctest.Run(func() {
    ch := make(chan int)
    go func() { time.Sleep(time.Second); ch <- 42 }() // fake clock
    synctest.Wait()
    val := <-ch
})

// os.Root — sandboxed filesystem
root, _ := os.OpenRoot("/data")
defer root.Close()
f, _ := root.Open("file.txt") // confined to /data

// b.Loop() for benchmarks
for b.Loop() { foo() }

// T.Context() and T.Chdir()
ctx := t.Context()       // cancelled when test ends
t.Chdir(t.TempDir())    // restores cwd after test

// weak pointers
ptr := weak.Make(&obj)
if strong := ptr.Value(); strong != nil { /* alive */ }

// runtime.AddCleanup — GC finalizer
runtime.AddCleanup(&obj, func(tok int) { cleanup(tok) }, token)

// Tool directives in go.mod
// tool ( golang.org/x/tools/cmd/goimports )

// omitzero JSON tag
type Config struct {
    Created time.Time `json:"created,omitzero"`
}

// Post-quantum crypto: crypto/mlkem