Generics

package main

import (
	"cmp"
	"fmt"
)

// MaxOf returns the larger of a and b. T may be any ordered type.
func MaxOf[T cmp.Ordered](a, b T) T {
	if a > b {
		return a
	}
	return b
}

// Before Go 1.18 the same idea needed one function per type...
func maxInt(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func maxString(a, b string) string {
	if a > b {
		return a
	}
	return b
}

// ...or an empty interface, which gives up static type checking.
func maxAny(a, b any) any {
	switch x := a.(type) {
	case int:
		if x > b.(int) {
			return a
		}
		return b
	case string:
		if x > b.(string) {
			return a
		}
		return b
	}
	panic("unsupported type")
}

func main() {
	fmt.Println(maxInt(3, 9), maxString("Dune", "Emma"), maxAny(2, 7))
	fmt.Println(MaxOf(3, 9), MaxOf("Dune", "Emma"), MaxOf(2.5, 1.5))
	// maxAny(2, "x") compiles but panics at run time; MaxOf(2, "x") does not compile.
}

9 Emma 7
9 Emma 2.5

package main

import (
	"fmt"
	"strconv"
)

// Map applies f to every element of s.
func Map[T, R any](s []T, f func(T) R) []R {
	out := make([]R, 0, len(s))
	for _, v := range s {
		out = append(out, f(v))
	}
	return out
}

// Convert has a type parameter that cannot be inferred from its arguments.
func Convert[To, From ~int | ~int64 | ~float64](v From) To { return To(v) }

type Pages int

func main() {
	pages := []int{412, 1032, 96}

	// Full explicit instantiation: both type arguments are given.
	a := Map[int, string](pages, strconv.Itoa)

	// Partial instantiation: T is given, R is inferred from f.
	b := Map[int](pages, func(n int) float64 { return float64(n) / 100 })

	// Full inference: T from pages, R from strconv.Itoa.
	c := Map(pages, strconv.Itoa)

	fmt.Printf("%q %v %q\n", a, b, c)

	// Only the first type argument is given; From is inferred from the argument.
	x := Convert[float64](Pages(412))
	fmt.Printf("%T %v\n", x, x)

	// Instantiating without calling yields an ordinary function value.
	f := Map[string, int]
	fmt.Printf("%T\n", f)
}

["412" "1032" "96"] [4.12 10.32 0.96] ["412" "1032" "96"]
float64 412
func([]string, func(string) int) []int

package main

import (
	"fmt"
	"maps"
	"slices"
)

type Pages int
type Counts []Pages

// Scale shows constraint type inference: E is not mentioned in any argument
// directly as a type, it is deduced from S's constraint ~[]E.
func Scale[S ~[]E, E ~int | ~float64](s S, k E) S {
	out := make(S, len(s))
	for i, v := range s {
		out[i] = v * k
	}
	return out
}

// Keys returns the keys of any map type M.
func Keys[M ~map[K]V, K comparable, V any](m M) []K {
	r := make([]K, 0, len(m))
	for k := range m {
		r = append(r, k)
	}
	return r
}

type Stock map[string]int

func main() {
	c := Scale(Counts{100, 200}, 3)
	fmt.Printf("%T %v\n", c, c)

	ks := Keys(Stock{"Dune": 3, "Emma": 1})
	slices.Sort(ks)
	fmt.Println(ks)
	fmt.Println(slices.Sorted(maps.Keys(Stock{"Hamlet": 2})))
}

main.Counts [300 600]
[Dune Emma]
[Hamlet]

package main

import (
	"fmt"
	"slices"
	"sort"
)

// Set is a generic set. The key type must be comparable so it can be a map key.
type Set[T comparable] map[T]struct{}

func NewSet[T comparable](items ...T) Set[T] {
	s := make(Set[T], len(items))
	for _, it := range items {
		s.Add(it)
	}
	return s
}

func (s Set[T]) Add(v T)      { s[v] = struct{}{} }
func (s Set[T]) Has(v T) bool { _, ok := s[v]; return ok }
func (s Set[T]) Len() int     { return len(s) }
func (s Set[T]) Union(o Set[T]) Set[T] {
	out := NewSet[T]()
	for k := range s {
		out.Add(k)
	}
	for k := range o {
		out.Add(k)
	}
	return out
}

// Stack shows the zero value of a type parameter: var zero T.
type Stack[T any] struct{ items []T }

func (s *Stack[T]) Push(v T) { s.items = append(s.items, v) }
func (s *Stack[T]) Pop() (T, bool) {
	var zero T
	if len(s.items) == 0 {
		return zero, false
	}
	v := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return v, true
}

// Pair has two type parameters.
type Pair[K comparable, V any] struct {
	Key K
	Val V
}

func (p Pair[K, V]) String() string { return fmt.Sprintf("%v=>%v", p.Key, p.Val) }

// SortedIndex keeps entries ordered by key, using binary search.
type SortedIndex[K interface{ ~string | ~int }, V any] struct {
	keys []K
	vals []V
}

func (x *SortedIndex[K, V]) Put(k K, v V) {
	i, found := slices.BinarySearch(x.keys, k)
	if found {
		x.vals[i] = v
		return
	}
	x.keys = slices.Insert(x.keys, i, k)
	x.vals = slices.Insert(x.vals, i, v)
}

func (x *SortedIndex[K, V]) Get(k K) (V, bool) {
	i, found := slices.BinarySearch(x.keys, k)
	if !found {
		var zero V
		return zero, false
	}
	return x.vals[i], true
}

func (x *SortedIndex[K, V]) Keys() []K { return slices.Clone(x.keys) }

func main() {
	a := NewSet("Dune", "Emma")
	b := NewSet("Emma", "Ulysses")
	u := a.Union(b)
	names := make([]string, 0, u.Len())
	for k := range u {
		names = append(names, k)
	}
	sort.Strings(names)
	fmt.Println(names, u.Has("Dune"), u.Has("Hamlet"))

	var st Stack[Pair[string, int]]
	st.Push(Pair[string, int]{"Dune", 412})
	st.Push(Pair[string, int]{"Emma", 474})
	top, _ := st.Pop()
	fmt.Println(top)
	_, _ = st.Pop()
	empty, ok := st.Pop()
	fmt.Printf("%v %t %q\n", empty, ok, empty.Key)

	var idx SortedIndex[string, int]
	for _, t := range []string{"Ulysses", "Dune", "Emma", "Dune"} {
		idx.Put(t, len(t))
	}
	v, _ := idx.Get("Emma")
	fmt.Println(idx.Keys(), v)
}

[Dune Emma Ulysses] true false
Emma=>474
=>0 false ""
[Dune Emma Ulysses] 4

package main

import (
	"cmp"
	"fmt"
	"maps"
	"slices"
	"strings"
)

type Book struct {
	Title string
	Year  int
}

// Filter returns the elements of s for which keep reports true.
func Filter[S ~[]E, E any](s S, keep func(E) bool) S {
	var out S
	for _, v := range s {
		if keep(v) {
			out = append(out, v)
		}
	}
	return out
}

// GroupBy partitions s by the key function.
func GroupBy[E any, K comparable](s []E, key func(E) K) map[K][]E {
	m := make(map[K][]E)
	for _, v := range s {
		k := key(v)
		m[k] = append(m[k], v)
	}
	return m
}

// Reduce folds s into a single value.
func Reduce[E, A any](s []E, init A, f func(A, E) A) A {
	acc := init
	for _, v := range s {
		acc = f(acc, v)
	}
	return acc
}

type Shelf []Book

func main() {
	books := Shelf{{"Dune", 1965}, {"Emma", 1815}, {"Ulysses", 1922}, {"Hamlet", 1603}}

	// The ~[]E form preserves the named slice type.
	modern := Filter(books, func(b Book) bool { return b.Year > 1900 })
	fmt.Printf("%T %v\n", modern, modern)

	byCentury := GroupBy(books, func(b Book) int { return b.Year / 100 * 100 })
	for _, c := range slices.Sorted(maps.Keys(byCentury)) {
		fmt.Println(c, byCentury[c])
	}

	chars := Reduce(books, 0, func(n int, b Book) int { return n + len(b.Title) })
	fmt.Println(chars)

	// The standard library versions.
	slices.SortFunc(books, func(a, b Book) int {
		return cmp.Or(cmp.Compare(a.Year, b.Year), strings.Compare(a.Title, b.Title))
	})
	fmt.Println(books)
	i, found := slices.BinarySearchFunc(books, 1922, func(b Book, year int) int { return cmp.Compare(b.Year, year) })
	fmt.Println(i, found)
	fmt.Println(slices.MaxFunc(books, func(a, b Book) int { return cmp.Compare(a.Year, b.Year) }))
	fmt.Println(slices.ContainsFunc(books, func(b Book) bool { return b.Title == "Emma" }))
}

main.Shelf [{Dune 1965} {Ulysses 1922}]
1600 [{Hamlet 1603}]
1800 [{Emma 1815}]
1900 [{Dune 1965} {Ulysses 1922}]
21
[{Hamlet 1603} {Emma 1815} {Ulysses 1922} {Dune 1965}]
2 true
{Dune 1965}
true

package main

import (
	"fmt"
	"iter"
	"slices"
	"strings"
)

// FilterSeq and MapSeq are generic iterator adapters.
func FilterSeq[V any](seq iter.Seq[V], keep func(V) bool) iter.Seq[V] {
	return func(yield func(V) bool) {
		for v := range seq {
			if keep(v) && !yield(v) {
				return
			}
		}
	}
}

func MapSeq[V, R any](seq iter.Seq[V], f func(V) R) iter.Seq[R] {
	return func(yield func(R) bool) {
		for v := range seq {
			if !yield(f(v)) {
				return
			}
		}
	}
}

func main() {
	titles := []string{"Dune", "Emma", "Ulysses", "Hamlet"}
	long := FilterSeq(slices.Values(titles), func(s string) bool { return len(s) > 4 })
	upper := MapSeq(long, strings.ToUpper)
	fmt.Println(slices.Collect(upper))
}

[ULYSSES HAMLET]

package main

import (
	"errors"
	"fmt"
	"sync"
)

// Repository is a generic interface: any entity type T with a key type K.
type Repository[K comparable, T any] interface {
	Get(K) (T, error)
	Put(K, T) error
}

var ErrNotFound = errors.New("not found")

// memRepo implements Repository[K, T] for every K and T.
type memRepo[K comparable, T any] struct {
	mu sync.Mutex
	m  map[K]T
}

func NewMemRepo[K comparable, T any]() *memRepo[K, T] {
	return &memRepo[K, T]{m: make(map[K]T)}
}

func (r *memRepo[K, T]) Get(k K) (T, error) {
	r.mu.Lock()
	defer r.mu.Unlock()
	v, ok := r.m[k]
	if !ok {
		var zero T
		return zero, fmt.Errorf("%v: %w", k, ErrNotFound)
	}
	return v, nil
}

func (r *memRepo[K, T]) Put(k K, v T) error {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.m[k] = v
	return nil
}

// Compile-time check that *memRepo[string, int] satisfies the instantiated interface.
var _ Repository[string, int] = (*memRepo[string, int])(nil)

type Book struct{ Title string }

// Lend accepts the interface, as in "accept interfaces, return structs".
func Lend(r Repository[string, Book], isbn string) (string, error) {
	b, err := r.Get(isbn)
	if err != nil {
		return "", err
	}
	return b.Title, nil
}

// Container is a generic interface used as a constraint: C must provide
// Len and At for the element type E.
type Container[E any] interface {
	Len() int
	At(int) E
}

type list[E any] []E

func (l list[E]) Len() int   { return len(l) }
func (l list[E]) At(i int) E { return l[i] }

func All[E any, C Container[E]](c C) []E {
	out := make([]E, 0, c.Len())
	for i := range c.Len() {
		out = append(out, c.At(i))
	}
	return out
}

func main() {
	r := NewMemRepo[string, Book]()
	_ = r.Put("9780441172719", Book{"Dune"})
	t, err := Lend(r, "9780441172719")
	fmt.Println(t, err)
	_, err = Lend(r, "0000000000000")
	fmt.Println(err, errors.Is(err, ErrNotFound))

	fmt.Println(All[string](list[string]{"x", "y"}))
}

Dune <nil>
0000000000000: not found true
[x y]

package main

import "fmt"

type Set[T comparable] map[T]struct{}

// A generic alias: Index[V] is the same type as map[string]V.
type Index[V any] = map[string]V

// An alias may fix some arguments of a generic type: ISBNSet is Set[string].
type ISBNSet = Set[string]

// An alias may also instantiate a generic type partially.
type Result[T any] = struct {
	Val T
	Err error
}

func main() {
	var byISBN Index[int] = map[string]int{"9780441172719": 412}
	var plain map[string]int = byISBN // identical types: no conversion needed
	fmt.Printf("%T %v\n", byISBN, plain)

	s := ISBNSet{"9780441172719": {}}
	var t Set[string] = s
	fmt.Printf("%T %d\n", t, len(t))

	r := Result[int]{Val: 3}
	fmt.Printf("%T %+v\n", r, r)
}

map[string]int map[9780441172719:412]
main.Set[string] 1
struct { Val int; Err error } {Val:3 Err:<nil>}

package main

import (
	"fmt"
	"strings"
)

// Adder may require that it be instantiated with a type like itself (Go 1.26).
type Adder[A Adder[A]] interface {
	Add(A) A
}

func Fold[A Adder[A]](zero A, vs ...A) A {
	acc := zero
	for _, v := range vs {
		acc = acc.Add(v)
	}
	return acc
}

// Pages adds page counts.
type Pages int

func (p Pages) Add(o Pages) Pages { return p + o }

// Title concatenates words.
type Title string

func (t Title) Add(o Title) Title { return Title(strings.TrimSpace(string(t) + " " + string(o))) }

// Ordered-style self reference: a value that can compare itself with another of its own type.
type Comparer[T Comparer[T]] interface {
	Compare(T) int
}

type Year int

func (y Year) Compare(o Year) int { return int(y - o) }

func Newest[T Comparer[T]](vs ...T) T {
	best := vs[0]
	for _, v := range vs[1:] {
		if v.Compare(best) > 0 {
			best = v
		}
	}
	return best
}

func main() {
	fmt.Println(Fold(Pages(0), 412, 1032, 96))
	fmt.Printf("%q\n", Fold(Title(""), "Dune", "Messiah"))
	fmt.Println(Newest(Year(1965), Year(1815), Year(1922)))
}

1540
"Dune Messiah"
1965

package main

import (
	"fmt"
	"strconv"
)

type List[E any] struct{ elems []E }

func NewList[E any](elems ...E) List[E] { return List[E]{elems: elems} }

// Map is a generic method: it has its own type parameter R besides the receiver's E.
func (l List[E]) Map[R any](f func(E) R) List[R] {
	out := make([]R, 0, len(l.elems))
	for _, e := range l.elems {
		out = append(out, f(e))
	}
	return List[R]{elems: out}
}

func (l List[E]) String() string { return fmt.Sprint(l.elems) }

// Reduce shows two things: a method type parameter used in a result, and inference of R.
func (l List[E]) Reduce[A any](init A, f func(A, E) A) A {
	acc := init
	for _, e := range l.elems {
		acc = f(acc, e)
	}
	return acc
}

func main() {
	pages := NewList(412, 1032, 96)

	// R is inferred from the function argument; calls chain left to right.
	labels := pages.Map(strconv.Itoa).Map(func(s string) string { return s + "p" })
	fmt.Println(labels)

	// Explicit instantiation of the method.
	fmt.Println(pages.Map[float64](func(n int) float64 { return float64(n) / 2 }))

	// Reduce infers A from init.
	fmt.Println(pages.Reduce(0, func(a, n int) int { return a + n }))

	// A method expression turns the generic method into a plain function.
	f := List[int].Map[string]
	fmt.Println(f(pages, func(n int) string { return fmt.Sprintf("#%d", n) }))
}

[412p 1032p 96p]
[206 516 48]
1540
[#412 #1032 #96]

package main

import "fmt"

// BytesOrString has no core type: its type set mixes []byte and string.
type BytesOrString interface{ ~[]byte | ~string }

// Indexing is valid for every type in the type set (and the element types agree).
func At[S BytesOrString](s S, i int) byte { return s[i] }

// Slicing a type set with differing underlying types: the spec rule is explicit
// prose since Go 1.25 (before, it was phrased through "core types").
func Head[S BytesOrString](s S, n int) S { return s[:n] }

// len works on any type whose type set agrees that len is valid.
func Size[S BytesOrString](s S) int { return len(s) }

// send needs every channel in the type set to allow sending.
func Send[C ~chan int | ~chan<- int](c C, v int) { c <- v }

// Conversions between type parameters work if all pairs are convertible.
func Bytes[S BytesOrString](s S) []byte { return []byte(s) }

func main() {
	fmt.Println(At("Dune", 1), At([]byte("Dune"), 1))
	fmt.Println(Head("Dune", 2), string(Head([]byte("Emma"), 3)))
	fmt.Println(Size("Ulysses"), Size([]byte("héllo")))
	c := make(chan int, 1)
	Send(c, 7)
	fmt.Println(<-c, Bytes("ab"))
}

117 117
Du Emm
7 6
7 [97 98]

package main

type BytesOrString interface{ ~[]byte | ~string }

func Count[S BytesOrString](s S) int {
	n := 0
	for range s {
		n++
	}
	return n
}

func main() {}

# example.com/shelf
./main.go:7:12: cannot range over s (variable of type S constrained by BytesOrString): []byte and string have different underlying types

package main

type XOnly interface{ ~struct{ X int } }

func GetX[T XOnly](v T) int { return v.X }

func main() {}

# example.com/shelf
./main.go:5:40: v.X undefined (type T has no field or method X)