Robert Griesemer & Ian Lance Taylor Generics GopherCon 2021

[P, Q constraint#1, R constraint#2]

func min(x, y float64) float64 {  if x < y {    return x  }  return y}

func min[T constraints.Ordered](x, y T) T {  if x < y {    return x  }  return y}

m := min[int](2, 3)

fmin := min[float64]m := fmin(2.71, 3.14)

type Tree[T interface{}] struct {  left, right *Tree[T]  data        T}func (t *Tree[T]) Lookup(x T) *Tree[T]var stringTree Tree[string]

interface {  int|string|bool}

package constraintstype Ordered interface {  Integer|Float|~string}

[S interface{ ~[]E }, E interface{}]

[S ~[]E, E interface{}]

[S ~[]E, E any]

func min[T constraints.Ordered](x, y T) Tvar a, b, m float64m = min[float64](a, b)

m = min(a, b)

type Tree[T any] struct {  cmp  func(T, T) int  root *node[T]}type node[T any] struct {  left, right *node[T]  data}func (bt *Tree[T]) find(val T) **node[T] {  pl := &bt.root  for *pl != nil {    switch cmp := bt.cmp(val, (*pl).data); {      case cmp < 0: pl = &(*pl).left      case cmp > 0: pl = &(*pl).right      default: return pl    }  }  return pl}

type SliceFn[T any] struct {  s []T  cmp func(T, T) bool}func (s SliceFn[T]) Len() int { return len(s.s) }func (s SliceFn[T]) Swap(i, j int) {  s.s[i], s.s[j] = s.s[j], s.s[i]) }func (s SliceFn[T]) Less(i, j int) bool {  return s.cmp(s.s[i], s.s[j]) }func SortFn[T any](s []T, cmp func(T, T) bool) {  sort.Sort(SliceFn[T]{s, cmp})}