Writing a Go Closure, Head first.

• Let’s create a factory function called createAdder that returns the currentValue and add function to add integers to the variable.
• This demonstrates a classic usecase of a closure.
• We start by writing a closure in go just as we do in any other scripting language. Below would be the code if we did a head first dive and wrote a closure.
• We create createAdder function that supposedly returns a lexicographically scoped variable currentValue and a add function that adds a number provided as a parameter to that variable.

1
package main
2

3
import "fmt"
4

5
func createAdder() (int, func(int)) {
6
    currentValue := 0
7

8
    add := func(val int) {
9
      currentValue += val
10
    }
11

12
    return currentValue, add
13
}
14

15
func main() {
16
    currentValue, add := createAdder()
17
    fmt.Println("Before:", currentValue)
18

19
    add(1)
20
    add(2)
21
    fmt.Println("After:", currentValue)
22
}

• Lets run it with go run main.go and see the output.

1
Before: 0
2
After: 0

Why does it not work?

• The reason it doesn’t work is unlike languages like javascript or python, go being a compiled language actually supports primitives. In javascript or python everything is as object, even seemingly primitive types.
• The currentValue which was unpacked at the line no. 16 is a primitive and got updated (when a primitive is reassigned, any previous copies become stale) after we made an add call. But we kept the stale reference and it tried to access that.

Writing a Go closure the right way

• There are actually two ways we can write a closure.
  1. Write a closure and return a value. The function caller has to always reference the returned value.
  2. Use a pointer reference.

Writing a closure with return value

• We update our code to always return the updated outer scoped variable.
• The function caller makes sure post each operation, it captures the newly updated value.

1
package main
2

3
import "fmt"
4

5
 func createAdder() (int, func(int)) {
6
 func createAdder() (int, func(int) int) {
7
  currentValue := 0
8

9
   add := func(val int) {
10
   add := func(val int) int {
11
     currentValue += val
12
     return currentValue
13
    }
14

15
    return currentValue, add
16
}
17

18
func main() {
19
    currentValue, add := createAdder()
20
    fmt.Println("Before:", currentValue)
21

22
   add(1)
23
   add(2)
24
   currentValue = add(1)
25
   currentValue = add(2)
26
    fmt.Println("After:", currentValue)
27
}

• Lets run it again now.

1
Before: 0
2
After: 3

Writing a closure with pointer reference

• We now return a reference of a variable instead and the function caller will treat it as a pointer and deference it to access the actual value
• This is inline with classic use-case of a closure.

1
package main
2

3
import "fmt"
4

5
 func createAdder() (int, func(int)) {
6
 func createAdder() (*int, func(int)) {
7
    currentValue := 0
8

9
    add := func(val int) {
10
      currentValue += val
11
    }
12

13
   return currentValue, add
14
   return &currentValue, add
15
}
16

17
func main() {
18
    currentValue, add := createAdder()
19
    fmt.Println("Before:", currentValue)
20
    fmt.Println("Before:", *currentValue)
21

22
    add(1)
23
    add(2)
24
    fmt.Println("After:", currentValue)
25
    fmt.Println("After:", *currentValue)
26
}

This is true for any compiled language that defines primitives