Master Go Closures, Anonymous Functions, and Higher‑Order Functions

In software development, closures, anonymous functions, functions as parameters, and functions as return values are fundamental concepts that enhance data encapsulation, modularity, and code brevity. This article explains each concept and demonstrates practical Go implementations.

Closure

A closure is a function value that captures variables from its surrounding lexical scope, allowing the inner function to access and modify those variables even after the outer function has returned.

Go closure example

package main

import "fmt"

func accumulator(value int) func() int {
    sum := value
    return func() int {
        sum += value
        return sum
    }
}

func main() {
    acc := accumulator(10)
    fmt.Println(acc()) // 输出：20
    fmt.Println(acc()) // 输出：30
}

The accumulator function returns a closure that continues to access the variable sum outside its original scope.

Anonymous Function

An anonymous function has no name and can be defined and invoked directly where needed, which is handy for callbacks and closures.

Go anonymous function example

package main

import "fmt"

func main() {
    func(msg string) {
        fmt.Println(msg)
    }("Hello, Go!") // 直接定义并调用匿名函数，输出：Hello, Go!
}

Function as Parameter

Go supports higher‑order functions, allowing a function to be passed as an argument to another function, which increases flexibility in code logic.

Go example

package main

import "fmt"

func compute(fn func(float64, float64) float64) float64 {
    return fn(3, 4)
}

func main() {
    hypot := func(x, y float64) float64 {
        return math.Sqrt(x*x + y*y)
    }
    fmt.Println(compute(hypot))  // 输出：5
}

The compute function receives another function as its parameter, demonstrating increased flexibility and reusability.

Function as Return Value (Function Generator)

Returning functions enables dynamic creation of behavior at runtime, supporting patterns such as factories, strategy, and pipelines.

Go function generator example

package main

import (
    "fmt"
)

type mathOperation func(float64, float64) float64

func getMathOperation(op string) mathOperation {
    switch op {
    case "+":
        return func(x, y float64) float64 { return x + y }
    case "-":
        return func(x, y float64) float64 { return x - y }
    case "*":
        return func(x, y float64) float64 { return x * y }
    case "/":
        return func(x, y float64) float64 {
            if y != 0 {
                return x / y
            }
            return 0 // simple error handling
        }
    default:
        return nil
    }
}

func main() {
    add := getMathOperation("+")
    fmt.Println("5 + 6 =", add(5, 6))

    subtract := getMathOperation("-")
    fmt.Println("10 - 3 =", subtract(10, 3))

    multiply := getMathOperation("*")
    fmt.Println("7 * 8 =", multiply(7, 8))

    divide := getMathOperation("/")
    fmt.Println("9 / 3 =", divide(9, 3))
    fmt.Println("9 / 0 =", divide(9, 0)) // division‑by‑zero not handled here
}

This generator returns different arithmetic functions based on the supplied operator string, illustrating how functions as return values provide great flexibility and expressive power in Go programs.

Conclusion

Closures, anonymous functions, and higher‑order functions are powerful features of Go that make programs more flexible and modular. Mastering these concepts helps developers write efficient, maintainable Go code.