Why Practice Functional Programming in Go? 5 Hands‑On Examples

Why Use Functional Programming in Go?

Functional programming (FP) emphasizes pure functions, immutability, and the avoidance of shared state, making code easier to read, test, and debug. By isolating functions from hidden state, errors become simpler to trace.

Four Core FP Concepts

Pure Functions & Idempotence : Same input always yields the same output.

Side Effects : Pure functions must not interact with external environments such as APIs, I/O, or mutable state.

Function Composition : Combine pure functions to build more complex behavior.

Shared State & Immutable Data : Avoid mutable data; when state is required, make it explicit and immutable.

Practical FP Rules for Go

Avoid mutable data to prevent side effects.

Prefer stateless functions (or implicit state like loop counters).

Do not modify variables after assignment.

Minimize side effects, e.g., avoid direct API calls inside pure functions.

Five Illustrative Examples

1. Updating a String without Mutation

Instead of reassigning a variable, create new values for each step.

firstname := "first"
lastname := "last"
fullname := firstname + " " + lastname

2. Updating an Array Immutably

Create a new slice rather than modifying the original.

names := []string{"Tom", "Ben"}
allNames := append(names, "Lucas")

3. Updating a Map Immutably

Construct a new map and merge the original with the new entries.

fruits := map[string]int{"bananas": 11}
newFruits := map[string]int{"apples": 5}
allFruits := make(map[string]int, len(fruits)+len(newFruits))
for k, v := range fruits { allFruits[k] = v }
for k, v := range newFruits { allFruits[k] = v }

4. Higher‑Order Functions & Currying

Define a function that returns another function, capturing the first argument.

func add(x int) func(y int) int {
    return func(y int) int { return x + y }
}
func main() {
    add10 := add(10)
    add20 := add(20)
    fmt.Println(add10(1)) // 11
    fmt.Println(add20(1)) // 21
}

5. Recursion for Factorial

Replace loops with recursive calls to stay within the FP paradigm.

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

Conclusion

Go supports functional programming but lacks built‑in map, filter, and reduce utilities.

Pure functions improve readability and testability by eliminating hidden state.

Immutability and function composition lead to more reliable, modular code.