Mastering Higher-Order Functions in Go: Decorators, Strategies, and Pipelines

Abstract

In Go, functions are first‑class citizens that can be passed around and combined like values. Mastering higher‑order functions enables concise, extensible code and elegant implementations of decorators, strategy, and pipeline design patterns.

1. Why Talk About Higher‑Order Functions in Go?

Many Go developers rely on structs and interfaces, assuming functional programming is out of reach. However, Go treats functions as first‑class citizens: they can be assigned to variables, passed as arguments, and returned from other functions, allowing clean decoupling for logging, rate‑limiting, retries, and stream processing.

2. Definition

A function is considered higher‑order if it satisfies at least one of the following:

Accepts another function as a parameter.

Returns a function as its result.

Example 1 – Function as Parameter

func applyToInt(x int, fn func(int) int) int {
    return fn(x)
}

func square(n int) int { return n * n }

func main() {
    res := applyToInt(5, square)
    fmt.Println(res) // 25
}

Example 2 – Function as Return Value

func makeAdder(delta int) func(int) int {
    return func(x int) int { return x + delta }
}

func main() {
    add5 := makeAdder(5)
    fmt.Println(add5(10)) // 15
}

3. Common Scenarios for Higher‑Order Functions in Go

Decorator : logging, rate‑limiting, retry, authentication – reusable cross‑cutting logic.

Strategy Pattern : dynamically choose algorithms, reducing if/else chains.

Pipeline Composition : stream‑style data processing with clear, readable code.

Error Wrapping : centralize error handling while keeping business logic pure.

4. Implementing the Decorator Pattern

type HandlerFunc func(ctx context.Context, req interface{}) (interface{}, error)

func WrapWithLogging(orig HandlerFunc) HandlerFunc {
    return func(ctx context.Context, req interface{}) (interface{}, error) {
        start := time.Now()
        log.Printf("start: %+v", req)
        resp, err := orig(ctx, req)
        log.Printf("done: resp=%+v err=%v cost=%v", resp, err, time.Since(start))
        return resp, err
    }
}

// Chain multiple decorators
wrapped := WrapWithLogging(WrapWithRetry(WrapWithTimeout(MyBusiness)))

5. Strategy Pattern with Function Parameters

type DiscountFunc func(amount float64) float64

func ApplyDiscount(amount float64, strategy DiscountFunc) float64 {
    return strategy(amount)
}

func TenPercentOff(a float64) float64 { return a * 0.9 }

func FullMinus100(a float64) float64 {
    if a >= 500 { return a - 100 }
    return a
}

fmt.Println(ApplyDiscount(600, TenPercentOff))   // 540
fmt.Println(ApplyDiscount(600, FullMinus100)) // 500

6. Function Pipeline / Composition

type IntTransform func(int) int

func Chain(funcs ...IntTransform) IntTransform {
    return func(x int) int {
        r := x
        for _, f := range funcs {
            r = f(r)
        }
        return r
    }
}

7. Higher‑Order Functions with Generics (Go 1.18+)

type Transformer[T any] func(T) T

func ChainGen[T any](funcs ...Transformer[T]) Transformer[T] {
    return func(x T) T {
        r := x
        for _, f := range funcs {
            r = f(r)
        }
        return r
    }
}

8. Practical Tips

Keep function signatures consistent.

Unify error and panic handling.

Beware of closure variable capture.

Avoid excessive wrapping in performance‑critical paths.

Document functions uniformly.

9. Real‑World Example: HTTP Middleware Chain

type HandlerFunc func(w http.ResponseWriter, r *http.Request)

type Middleware func(HandlerFunc) HandlerFunc

func ChainMiddleware(mws ...Middleware) Middleware {
    return func(final HandlerFunc) HandlerFunc {
        h := final
        for i := len(mws) - 1; i >= 0; i-- {
            h = mws[i](h)
        }
        return h
    }
}

// Usage
chain := ChainMiddleware(LoggingMiddleware, AuthMiddleware)
http.HandleFunc("/hello", chain(HelloHandler))

10. Conclusion

Higher‑order functions are practical, not merely academic.

Typical use‑cases include decorators, strategy, pipelines, and middleware.

Balance elegant abstraction with runtime overhead.

Combined with generics, they enable powerful, reusable utilities.