Go Interfaces Quick Reference Cheat Sheet

// Interface definition
type Reader interface {
    Read(p []byte) (n int, err error)
}

// Implicit implementation
type File struct{}
func (f *File) Read(p []byte) (int, error) {
    return 0, nil
}

// Type assertion
var r Reader = &File{}
f, ok := r.(*File)

// Interface composition
type ReadWriter interface {
    Reader
    Writer
}

// Error wrapping pattern
if err != nil {
    return fmt.Errorf("operation failed: %w", err)
}

// Table-driven tests
tests := []struct{
    name string
    input int
    want  int
}{
    {"positive", 5, 25},
    {"zero", 0, 0},
}
for _, tt := range tests {
    t.Run(tt.name, func(t *testing.T) {
        got := Square(tt.input)
        if got != tt.want { t.Errorf(...) }
    })
}

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

// Custom error type
type ValidationError struct {
    Field   string
    Message string
}
func (e *ValidationError) Error() string {
    return fmt.Sprintf("%s: %s", e.Field, e.Message)
}

// Multi-error handling
var errs []error
for _, item := range items {
    if err := validate(item); err != nil {
        errs = append(errs, err)
    }
}
return errors.Join(errs...)

// Generics (Go 1.18+)
func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

// Type constraints
type Number interface {
    ~int | ~float64
}

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

func TestAdd(t *testing.T) {
    got := Add(2, 3)
    if got != 5 {
        t.Errorf("Add(2,3) = %d; want 5", got)
    }
}

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

func FuzzParse(f *testing.F) {
    f.Add("42")
    f.Fuzz(func(t *testing.T, s string) {
        Parse(s) // should not panic
    })
}