












Closures and Higher-Order Functions
Introduction to Closures and Higher-Order Functions
Closures and higher-order functions are two foundational concepts in functional programming. Together, they enable powerful patterns like function factories, partial application, and data encapsulation.
What is a Closure?
A closure is a function that "remembers" variables from its lexical scope even when it's executed outside of that scope.
To put it simply, if an inner function uses variables from an outer function, and the inner function is returned or passed around, it "closes over" those variables, keeping them alive.
Example: Closure that Remembers
function makeCounter():
count = 0
function increment():
count = count + 1
return count
return increment
counterA = makeCounter()
print(counterA()) # 1
print(counterA()) # 2
counterB = makeCounter()
print(counterB()) # 1
1 2 1
Explanation
The inner function increment()
"remembers" the value of count
from its outer function makeCounter()
, even after makeCounter()
has finished executing. This is a closure.
Question:
Why does counterB()
start from 1 again?
Answer: Because each call to makeCounter()
creates a new scope with its own count
. Each closure maintains its own private memory.
What is a Higher-Order Function?
A higher-order function is a function that either:
- Accepts another function as an argument
- Returns another function
These functions allow us to abstract over actions, not just values.
Example: Passing Function as an Argument
function double(x):
return x * 2
function applyFunction(f, value):
return f(value)
result = applyFunction(double, 5)
print(result)
10
Here, applyFunction
is a higher-order function because it takes another function double
as input.
Example: Returning a Function (Function Factory)
function createMultiplier(factor):
function multiply(x):
return x * factor
return multiply
times3 = createMultiplier(3)
print(times3(4)) # 12
times10 = createMultiplier(10)
print(times10(2)) # 20
12 20
This is a classic closure + higher-order function pattern: createMultiplier
returns a function that retains access to the factor
passed to it. Each returned function has its own enclosed environment.
Question:
How is this useful in real scenarios?
Answer: Closures and higher-order functions allow us to create configurable functions (like times3
or times10
) and reduce repetition in code, improving modularity and reusability.
Recap
- Closure: A function that captures variables from its surrounding scope.
- Higher-Order Function: A function that takes or returns another function.
- Combining them enables advanced patterns like function factories and callback-based control flow.
Practice Thought
Try writing a function that keeps a running total and returns it every time it’s called. Can you implement it using closures?