Closures

A closure is a function that references variables from outside its own function body. The function may access and assign to the referenced variables.

In this example, the concatter() function returns a function that has reference to an enclosed doc value. Each successive call to harryPotterAggregator mutates that same doc variable.

func concatter() func(string) string {
	doc := ""
	return func(word string) string {
		doc += word + " "
		return doc
	}
}

func main() {
	harryPotterAggregator := concatter()
	harryPotterAggregator("Mr.")
	harryPotterAggregator("and")
	harryPotterAggregator("Mrs.")
	harryPotterAggregator("Dursley")
	harryPotterAggregator("of")
	harryPotterAggregator("number")
	harryPotterAggregator("four,")
	harryPotterAggregator("Privet")

	fmt.Println(harryPotterAggregator("Drive"))
	// Mr. and Mrs. Dursley of number four, Privet Drive
}

Assignment

Keeping track of how many texts we send is mission-critical at Textio. Complete the adder() enclosing function It should return a function that adds its input (an int) to an enclosed sum value, then return the new sum. In other words, it keeps a running total of the sum variable within a closure.

package main

func adder() func(int) int {
	sum := 0
	return func(number int) int {
		sum += number
		return sum
	}
}

🧩 The function definition

func adder() func(int) int

means:

"adder is a function that returns another function — and that inner function takes an int and returns an int."

So:

• The outer function: adder()

• The inner function: func(int) int

---

1

1️⃣ Outer function

func adder() func(int) int {
	sum := 0
	// returns another function
	return func(number int) int {
		sum += number
		return sum
	}
}

When you call adder(), it:

• Creates a local variable sum (set to 0)

• Returns a new function (the anonymous one inside)

• That inner function has access to the variable sum — even after adder() finishes!

This is called a closure — it “closes over” the sum variable and keeps it alive.

2

2️⃣ Inner function

func(number int) int {
	sum += number
	return sum
}

The inner function takes a number, adds it to sum, and returns the total.

Key point: Each time you call this returned function, it keeps using the same sum variable from when it was created.

---

⚙️ Using it in action

Let’s add a main():

func main() {
	add := adder() // returns a function

	fmt.Println(add(3))  // sum = 3
	fmt.Println(add(5))  // sum = 8
	fmt.Println(add(10)) // sum = 18
}

Output:

3
8
18

Here’s what happens:

1. adder() creates its own sum = 0 and returns a function.

2. When you call add(3), that inner function updates the same sum to 3.

3. When you call add(5), it adds to that same sum (now 8).

4. When you call add(10), it adds again (now 18).

The outer variable sum persists between calls because of the closure.

---

🧠 Visualization

adder() ───► returns ──► func(number int) int
   │                           ▲
   │                           │
   └── keeps its own "sum" ─────┘ (closure)

Every time you call adder(), you get a new copy of that closure and its own sum.

---

✅ TL;DR

Part	Meaning
func adder()	A function named adder
func(int) int	The type of function it returns (takes an int, returns an int)
Inner func(number int) int	The actual function being returned
sum	A variable captured by the closure, preserved across calls

---

⚙️ Bonus example

You can even create multiple independent adders:

addA := adder()
addB := adder()

fmt.Println(addA(1)) // 1
fmt.Println(addA(2)) // 3

fmt.Println(addB(10)) // 10 (separate sum)
fmt.Println(addB(5))  // 15

Each has its own sum — they don’t interfere with each other.

---

So the magic is:

func adder() func(int) int means “a function that returns a function,” and that returned function remembers the variable from the outer one — that’s a closure.

---

🧠 What’s really happening

When you call:

add := adder()

you’re doing two things:

1. Calling the function adder()

2. Storing whatever adder() returns into a variable named add.

---

⚙️ What does adder() return?

It returns another function — specifically, this one:

func(number int) int {
	sum += number
	return sum
}

That inner function has no name — it’s anonymous — but you’re saving it into the variable add.

So add now points to that returned function.

---

✅ So when you later write:

add(3)

you’re just calling the function that add is storing.

It’s exactly the same idea as:

f := func(x int) int {
	return x * 2
}

fmt.Println(f(10)) // prints 20

You gave the anonymous function a name by assigning it to a variable — here f, in your example add.

---

💡 Analogy

Think of adder() like a machine that builds a custom calculator for you.

add := adder() // You just built one calculator and named it "add"

Now whenever you use it:

add(3)
add(5)

…it’s using that same calculator, which remembers its total (sum).

If you called:

add2 := adder()

You’d get a second calculator with its own memory.

---

🔍 Summary

Concept	Explanation
Anonymous function	A function with no name (func(number int) int { ... })
add := adder()	Calls adder() and stores the returned (anonymous) function in add
add(3)	Calls the function stored in add
Why it works	Because functions in Go are values — you can assign them to variables and call them later

---

So yes — you gave the returned anonymous function the name add yourself when you did this:

add := adder()

You could have called it literally anything:

coolMathThing := adder()
fmt.Println(coolMathThing(5))

It would behave the same way.