Type Constraints

type Constraint interface {
    ~int | ~float64 | string
}

func Name[T Constraint](param T) T {
    // body
}

package main

import "fmt"

type Ordered interface {
	int | int64 | float64 | string
}

func Max[T Ordered](a, b T) T {
	if a > b {
		return a
	}
	return b
}

func main() {
	fmt.Println(Max(3, 9))
	fmt.Println(Max("apple", "banana"))
}

package main

import "fmt"

type Stringer interface {
	String() string
}

func PrintAll[T Stringer](items []T) {
	for _, item := range items {
		fmt.Println(item.String())
	}
}

type Item struct {
	Name string
}

func (i Item) String() string { return "Item: " + i.Name }

func main() {
	PrintAll([]Item{{Name: "Pen"}, {Name: "Book"}})
}

package main

import "fmt"

type Numeric interface {
	~int | ~float64
}

func Average[T Numeric](nums []T) float64 {
	var total T
	for _, n := range nums {
		total += n
	}
	return float64(total) / float64(len(nums))
}

func main() {
	fmt.Println(Average([]int{2, 4, 6}))
}

Type Parameters · Type Switches · Type Assertions · Type Conversion

1. Defining a constraint interface but forgetting a union of types (int | float64) is what actually allows arithmetic operators, not method requirements alone.
2. Trying to use a struct's own methods as an implicit constraint without explicitly declaring an interface listing them.
3. Overcomplicating a constraint when the built-in any or the standard library's constraints/cmp package already covers the need.

• A constraint is an interface that limits which types can be substituted for a type parameter.
• A union of types, like int | float64, is used in a constraint to allow operators such as + or <.
• The built-in comparable constraint allows == and != on a type parameter.
• Constraints can also require specific methods, just like any regular interface.