How to Implement Recursive Anonymous Functions in Go

When developing algorithms such as factorial calculation, recursion offers a concise and powerful solution. In Go, anonymous functions support recursion, but they cannot refer to themselves directly at declaration, so a variable must be used to hold the function.

The common technique is to declare a variable of the appropriate function type, assign the anonymous function to that variable, and then call the variable recursively inside the function body.

Example

The following program defines an anonymous recursive function that computes the factorial of a number:

package main

import "fmt"

func main() {
    // Use variable factorial to reference the anonymous function for recursion
    var factorial func(int) int

    factorial = func(n int) int {
        if n == 0 {
            return 1
        }
        return n * factorial(n-1)
    }

    // Call the anonymous recursive function
    fmt.Println(factorial(5)) // Output: 120
}

In this example, the variable factorial holds the anonymous function. Inside the function body, the same variable is used to invoke the function recursively, enabling the anonymous function to compute the factorial.

The key is declaring a variable with the type func(int) int before assigning the anonymous function. Once assigned, the function can refer to the variable for self‑calls, achieving recursion even without a named function.

Conclusion

By pre‑declaring a suitably typed variable and assigning an anonymous function to it, Go developers can implement recursive behavior in anonymous functions, expanding the language's expressive power for algorithmic problems.