Interfaces and Generics

type Stringer interface{ String() string }
type N int
func (n N) String() string { return fmt.Sprintf("%d", n) }
var s Stringer = N(3)
s.String()  // "3"

var i any = "hi"
s, ok := i.(string)
s  // "hi"
// ok == true

var i any = 7
s := ""
switch v := i.(type) {
case int:
    s = fmt.Sprintf("int %d", v)
default:
    s = "other"
}
s  // "int 7"

func First[T any](xs []T) (T, bool) {
    if len(xs) == 0 {
        var z T
        return z, false
    }
    return xs[0], true
}
v, ok := First([]int{9, 8})
v  // 9
// ok == true

func Max[T ~int | ~float64](a, b T) T {
    if a > b { return a }
    return b
}
Max(3, 5)  // 5

var x any = 1
x  // 1

var p *int
var i any = p
i == nil  // false (typed nil)

func Has[K comparable, V any](m map[K]V, k K) bool {
    _, ok := m[k]
    return ok
}
Has(map[string]int{"a": 1}, "a")  // true

type Pair[T any] struct{ A, B T }
Pair[int]{1, 2}.A  // 1

type Box[T any] struct{ V T }
func (b Box[T]) Get() T { return b.V }
Box[string]{V: "x"}.Get()  // "x"

type ReadWriter interface {
    io.Reader
    io.Writer
}
// types implementing both satisfy ReadWriter

// func Save(s Store) error
// prefer tiny interfaces at call sites

type ID int
func F[T ~int](v T) T { return v }
F(ID(2))  // 2

type Number interface{ ~int | ~float64 }
func Dbl[T Number](v T) T { return v + v }
Dbl(2.5)  // 5

var err error
err == nil  // true