What is a First-Order Function?
A first-order function is a function that does not take another function as an argument and does not return a function. It operates only on standard data types such as integers, strings, structs, arrays, etc.
In contrast, higher-order functions either take a function as an argument or return a function.
Characteristics of First-Order Functions
Takes and returns basic data types (int, string, struct, slice, etc.).
No function parameters (does not accept another function as an argument).
No function return values (does not return another function).
Easier to understand and use compared to higher-order functions.
Examples of First-Order Functions in Go
1️⃣ Simple Function with Primitive Data Types
This function takes two integers as input and returns their sum.
package main
import "fmt"
func add(a int, b int) int {
return a + b
}
func main() {
result := add(5, 3)
fmt.Println("Sum:", result) // Output: Sum: 8
}
✅ Why First-Order?
addoperates only on integer values.
- It neither accepts nor returns another function.
2️⃣ First-Order Function Using a Struct
A function that processes a struct (custom data type).
package main
import "fmt"
type User struct {
Name string
Age int
}
// Function that operates on a struct and returns a string
func greet(user User) string {
return "Hello, " + user.Name + "!"
}
func main() {
u := User{Name: "Alice", Age: 25}
message := greet(u)
fmt.Println(message) // Output: Hello, Alice!
}
✅ Why First-Order?
greetaccepts aUserstruct and returns astring.
- It does not accept or return functions.
3️⃣ First-Order Function with Slices
A function that processes an array or slice.
package main
import "fmt"
func sumArray(numbers []int) int {
sum := 0
for _, num := range numbers {
sum += num
}
return sum
}
func main() {
nums := []int{1, 2, 3, 4, 5}
fmt.Println("Total Sum:", sumArray(nums)) // Output: 15
}
✅ Why First-Order?
sumArrayprocesses a slice of integers.
- No function parameters or return values are involved.
How First-Order Functions Differ from Higher-Order Functions?
| Feature | First-Order Function | Higher-Order Function |
|---|---|---|
| Accepts Function as Parameter? | ❌ No | ✅ Yes |
| Returns Another Function? | ❌ No | ✅ Yes |
| Example | sumArray([]int) | operate(4, 2, func(x, y int) int { return x * y }) |
When to Use First-Order Functions?
✅ When working with simple computations that don’t need function references.
✅ When modularity and readability are more important than flexibility.
✅ When performing basic operations like calculations, struct processing, and data manipulation.