What are Go and functional programming patterns?

Question

Accepted Answer

Functional programming patterns in Go via **generics and closures**.

```go
// Map: transform elements
func Map[T any, U any](slice []T, fn func(T) U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = fn(v)
    }
    return result
}

// Filter: filtering
func Filter[T any](slice []T, fn func(T) bool) []T {
    result := make([]T, 0)
    for _, v := range slice {
        if fn(v) {
            result = append(result, v)
        }
    }
    return result
}

// Reduce: fold
func Reduce[T any, U any](slice []T, init U, fn func(U, T) U) U {
    result := init
    for _, v := range slice {
        result = fn(result, v)
    }
    return result
}

// FlatMap: transform + flatten
func FlatMap[T any, U any](slice []T, fn func(T) []U) []U {
    result := make([]U, 0)
    for _, v := range slice {
        result = append(result, fn(v)...)
    }
    return result
}

// Take: first N elements
func Take[T any](slice []T, n int) []T {
    if n > len(slice) {
        n = len(slice)
    }
    return slice[:n]
}

// Usage
users := []User{{Name: "Alice", Age: 25}, {Name: "Bob", Age: 30}}

names := Map(users, func(u User) string { return u.Name })
// ["Alice", "Bob"]

adults := Filter(users, func(u User) bool { return u.Age >= 18 })
// [{Alice 25}, {Bob 30}]

totalAge := Reduce(users, 0, func(sum int, u User) int { return sum + u.Age })
// 55

// Method chaining
result := Take(
    Filter(
        Map(users, func(u User) string { return u.Name }),
        func(s string) bool { return len(s) > 3 },
    ),
    5,
)
```

**Advantages:** Readability, composition, reuse.
**Disadvantages:** Allocations, performance (for hot paths).

Go: What are Go and functional programming patterns?