Generics

package main

import "fmt"

// Without generics: one function per type.
func maxInt(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// With generics: T is a type parameter, constrained to ordered types.
func Max[T int | float64 | string](a, b T) T {
	if a > b {
		return a
	}
	return b
}

func main() {
	fmt.Println(maxInt(3, 7))
	fmt.Println(Max(3, 7))            // T inferred as int
	fmt.Println(Max(2.5, 1.5))        // T inferred as float64
	fmt.Println(Max("go", "rust"))    // T inferred as string
	fmt.Println(Max[float64](3, 7.5)) // explicit: 3 becomes float64
}

package main

import (
	"cmp"
	"fmt"
)

// comparable: types that support == and != (needed for map keys too).
func Index[T comparable](items []T, target T) int {
	for i, v := range items {
		if v == target {
			return i
		}
	}
	return -1
}

// cmp.Ordered: every type that supports < <= > >=.
func Largest[T cmp.Ordered](items []T) T {
	best := items[0]
	for _, v := range items[1:] {
		if v > best {
			best = v
		}
	}
	return best
}

// A custom constraint. ~float64 means "float64 or any type whose underlying type is float64".
type Number interface {
	~int | ~int64 | ~float64
}

func Sum[T Number](nums []T) T {
	var total T // zero value of T
	for _, n := range nums {
		total += n
	}
	return total
}

type Celsius float64

func main() {
	fmt.Println(Index([]string{"a", "b", "c"}, "c"))
	fmt.Println(Index([]int{4, 5}, 9))
	fmt.Println(Largest([]float64{2.5, 9.1, 3}))
	fmt.Println(Largest([]string{"kiwi", "apple", "pear"}))
	fmt.Println(Sum([]int{1, 2, 3}))
	temps := []Celsius{20.5, 21, 19.5}
	fmt.Printf("%.1f %T\n", Sum(temps)/Celsius(len(temps)), Sum(temps))
}

package main

import "fmt"

// Stack is a generic type: T is fixed when you create one.
type Stack[T any] struct {
	items []T
}

func (s *Stack[T]) Push(v T) {
	s.items = append(s.items, v)
}

// Pop returns the top item and true, or the zero value and false when empty.
func (s *Stack[T]) Pop() (T, bool) {
	var zero T
	if len(s.items) == 0 {
		return zero, false
	}
	top := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return top, true
}

func (s *Stack[T]) Len() int { return len(s.items) }

func main() {
	var nums Stack[int]
	nums.Push(1)
	nums.Push(2)
	nums.Push(3)
	var popped []int
	for nums.Len() > 0 {
		v, _ := nums.Pop()
		popped = append(popped, v)
	}
	fmt.Println(popped) // last in, first out

	words := &Stack[string]{}
	words.Push("hello")
	w, ok := words.Pop()
	fmt.Printf("%q %v\n", w, ok)
	w, ok = words.Pop()
	fmt.Printf("%q %v\n", w, ok) // zero value of string
}

package main

import (
	"cmp"
	"fmt"
	"slices"
)

// Set is a generic set built on a map. Map keys only need comparable;
// cmp.Ordered (which implies comparable) is used so Sorted can sort them.
type Set[K cmp.Ordered] struct {
	m map[K]struct{}
}

func NewSet[K cmp.Ordered](items ...K) *Set[K] {
	s := &Set[K]{m: make(map[K]struct{})}
	for _, v := range items {
		s.Add(v)
	}
	return s
}

func (s *Set[K]) Add(v K)      { s.m[v] = struct{}{} }
func (s *Set[K]) Has(v K) bool { _, ok := s.m[v]; return ok }
func (s *Set[K]) Len() int     { return len(s.m) }

// Sorted returns the members in order, so printing never depends on map order.
func (s *Set[K]) Sorted() []K {
	out := make([]K, 0, len(s.m))
	for k := range s.m {
		out = append(out, k)
	}
	slices.Sort(out)
	return out
}

// Pair holds two values of different types.
type Pair[K comparable, V any] struct {
	Key K
	Val V
}

func main() {
	tags := NewSet("go", "rust", "go", "java")
	fmt.Println(tags.Len(), tags.Has("go"), tags.Has("php"))
	fmt.Println(tags.Sorted())

	ids := NewSet(3, 1, 2, 3)
	fmt.Println(ids.Sorted())

	p := Pair[string, float64]{"pi", 3.14}
	fmt.Printf("%+v\n", p)
}

package main

import (
	"fmt"
	"strings"
)

func Map[T, U any](items []T, f func(T) U) []U {
	out := make([]U, 0, len(items))
	for _, v := range items {
		out = append(out, f(v))
	}
	return out
}

func Filter[T any](items []T, keep func(T) bool) []T {
	var out []T
	for _, v := range items {
		if keep(v) {
			out = append(out, v)
		}
	}
	return out
}

func Reduce[T, A any](items []T, start A, f func(A, T) A) A {
	acc := start
	for _, v := range items {
		acc = f(acc, v)
	}
	return acc
}

func main() {
	words := []string{"go", "generics", "are", "handy"}

	lengths := Map(words, func(s string) int { return len(s) })
	fmt.Println(lengths)

	long := Filter(words, func(s string) bool { return len(s) > 3 })
	fmt.Println(long)

	upper := Map(long, strings.ToUpper)
	fmt.Println(upper)

	total := Reduce(lengths, 0, func(acc, n int) int { return acc + n })
	fmt.Println("total letters:", total)
}

package main

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

func main() {
	scores := []int{72, 95, 60, 88}
	fmt.Println(slices.Max(scores), slices.Min(scores))
	fmt.Println(slices.Contains(scores, 60), slices.Index(scores, 88))

	sorted := slices.Clone(scores) // copy, so scores is untouched
	slices.Sort(sorted)
	fmt.Println(scores, sorted)
	fmt.Println(slices.BinarySearch(sorted, 88))

	stock := map[string]int{"pear": 3, "apple": 5, "kiwi": 0}
	// Map order is random; sort the keys for stable output.
	keys := slices.Sorted(maps.Keys(stock))
	fmt.Println(keys)
	for _, k := range keys {
		fmt.Printf("%s=%d\n", k, stock[k])
	}

	backup := maps.Clone(stock)
	maps.DeleteFunc(stock, func(k string, v int) bool { return v == 0 })
	fmt.Println(len(stock), len(backup), maps.Equal(stock, backup))
}

package main

import (
	"fmt"
	"strings"
)

// Behaviour differs per type -> an interface, not a type parameter.
type Shape interface{ Area() float64 }

type Rect struct{ W, H float64 }
type Square struct{ S float64 }

func (r Rect) Area() float64   { return r.W * r.H }
func (s Square) Area() float64 { return s.S * s.S }

func totalArea(shapes []Shape) float64 {
	total := 0.0
	for _, s := range shapes {
		total += s.Area()
	}
	return total
}

// Same code for every element type -> a type parameter.
func Reverse[T any](s []T) []T {
	out := make([]T, len(s))
	for i, v := range s {
		out[len(s)-1-i] = v
	}
	return out
}

func main() {
	fmt.Println(totalArea([]Shape{Rect{2, 3}, Square{2}}))
	fmt.Println(Reverse([]int{1, 2, 3}))
	fmt.Println(strings.Join(Reverse([]string{"c", "b", "a"}), ""))
}