Class 23: Functional Programming Concepts in Go
Code Example
package main
import "fmt"
func add(a int, b int) { // Parameter: a and b
c := a + b
fmt.Println(c)
}
func main() {
add(2, 5) // 2 and 5 are arguments
processOperation(4, 5, add)
sum := call() // function expression
sum(4, 7)
}
func processOperation(a int, b int, op func(p int, q int)) { // Higher order function
op(a, b)
}
func call() func(x int, y int) {
return add
}
🧠 Key Concepts
1. Parameter vs Argument
- Parameter: The variable listed inside the function definition. (e.g.,
a int, b int
inadd(a, b)
) - Argument: The actual value passed to the function when it's called. (e.g.,
add(2, 5)
)
2. First Order Function
A regular function that does not take another function as input or return one.
- Examples:
- Named function:
func add(a, b int)
- Anonymous function:
func(a int, b int) { ... }
- IIFE (Immediately Invoked Function Expression):
func(a, b int) { ... }(5, 7)
- Function expression:
sum := func(a, b int) { ... }
- Named function:
3. Higher Order Function
A function that takes a function as a parameter, returns a function, or both.
- Example:
processOperation
takes a functionop
as a parametercall()
returns a functionadd
4. Callback Function
- A function that is passed into another function to be executed later.
- In
processOperation(4, 5, add)
, the functionadd
is a callback.
5. First-Class Citizen (Function)
- In Go, functions can be assigned to variables, passed as arguments, and returned from other functions.
- This makes them first-class citizens.
🧠 Conceptual Context (Functional Paradigm)
Functional programming treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data.
Inspiration from Mathematics
- First Order Logic: Objects with properties (e.g.,
Person
,Car
, etc.) - Higher Order Logic: Functions and their relation with other functions (like in Go's higher-order functions)
Languages like Haskell, Racket, etc., are built on deep functional paradigms.
Go borrows some of these concepts, but it is still imperative and procedural by nature.
📟 CLI Visualization (Call Stack + Segments)
1. Data Segment
add
(global function definition)call
(returns a function)processOperation
(stored function)
2. Code Execution Flow (Stack Frames)
Call Stack:
┌──────────────────────────┐
│ main() │
│ ├── add(2, 5) │ => prints 7
│ ├── processOperation │
│ │ └── op(4, 5) => add │ => prints 9
│ ├── call() │ => returns add
│ └── sum(4, 7) │ => prints 11
└──────────────────────────┘
Everything runs in the order written, but since functions are first-class, Go can pass and return them like variables.
Summary
- 🌱 Go supports functional programming concepts like first-class and higher-order functions.
- 💡 You can pass around functions like variables — extremely powerful for modular and clean code.
- 🧠 Understanding first order vs higher order functions, parameters vs arguments, and callback functions gives you a major edge in writing elegant Go code.
✅ This was a big brain class. You crushed it!