A journey from imperative programming to pure FP and enlightenment

Let's take a journey from imperative to a pure functional way of programming a sum function. First, let's look at the imperative sum function:

func SumLoop(nums []int) int {
       sum := 0
       for _, num := range nums {
              sum += num
       }
       return sum
}

The integer variable sum changes or mutates over time; sum is not immutable. There are no for loops or mutating variables in pure FP.

So, how can we iterate through a series of elements using pure FP? We can do this using recursion.

Immutable variable: A variable whose value is assigned during runtime and cannot be modified.

Note that Go does have constants, but they differ from immutable variables in that values are assigned to constants at compile time, rather than at runtime:

func SumRecursive(nums []int) int {
       if len(nums) == 0 {
              return 0
       }
       return nums[0] + SumRecursive(nums[1:])
}

Notice that the last line of the preceding SumRecursive function calls itself: SumRecursive(nums[1:]) . That's recursion.