Functional Programming in Go
Go is a pragmatic language that favors simplicity and readability over academic purity. While it is not a purely functional language like Haskell or Elm, Go offers first-class functions, closures, and a strong type system that allows developers to write code in a functional style. This tutorial explores how to leverage functional programming concepts to write cleaner, more testable, and more composable Go code.
What Is Functional Programming in Go?
Functional programming is a paradigm where computation is treated as the evaluation of mathematical functions, avoiding mutable state and side effects. In Go, functional programming means using functions as values, writing pure functions that don't modify external state, composing smaller functions into larger ones, and leveraging closures to encapsulate behavior. Go's support for first-class functions — functions that can be assigned to variables, passed as arguments, and returned from other functions — makes this possible.
Key functional concepts applicable in Go include:
- First-class functions — functions are values that can be stored, passed, and returned
- Higher-order functions — functions that take or return other functions
- Closures — functions that capture variables from their enclosing scope
- Pure functions — functions with no side effects that always return the same output for the same input
- Immutability — avoiding mutation of data in favor of creating new copies
- Function composition — combining simple functions to build complex logic
- Recursion — functions that call themselves instead of using loops
Why Functional Programming Matters in Go
Adopting a functional style in Go brings several practical benefits even in a language not designed around immutability:
- Testability — pure functions are trivial to test because they depend only on their inputs
- Concurrency safety — immutable data and stateless functions eliminate race conditions naturally
- Code reuse — higher-order functions allow you to abstract patterns like map, filter, and reduce
- Readability — small, composable functions with clear inputs and outputs are easier to reason about
- Fewer bugs — side-effect-free code reduces the surface area for unexpected behavior
Go's goroutines and channels already encourage a share-by-communicating model; functional programming complements this by making the data flowing through channels inherently safer to share.
Core Techniques
🚀 Deploy your AI agent in 10 minutes
Managed Hermes hosting. Zero DevOps. 100M tokens/mo included.
Try it free →First-Class Functions and Function Types
In Go, functions can be assigned to variables, stored in structs, passed as parameters, and returned. You can also define named function types for clarity and documentation.
package main
import "fmt"
// Define a function type for clarity
type Transformer func(int) int
// A simple function stored in a variable
func main() {
double := func(x int) int {
return x * 2
}
fmt.Println(double(5)) // Output: 10
// Passing a function as an argument
result := applyOperation(10, double)
fmt.Println(result) // Output: 20
// Using different operations
triple := func(x int) int { return x * 3 }
result = applyOperation(10, triple)
fmt.Println(result) // Output: 30
}
// Higher-order function that accepts a function as parameter
func applyOperation(x int, op Transformer) int {
return op(x)
}
Higher-Order Functions: Map, Filter, Reduce
Go lacks generics (before Go 1.18), but even with generics or type-specific implementations, you can build classic functional combinators. Here are implementations using Go 1.18+ generics for reusability, followed by concrete type versions.
package main
import "fmt"
// Generic Map: transforms each element using fn
func Map[T any, U any](slice []T, fn func(T) U) []U {
result := make([]U, len(slice))
for i, v := range slice {
result[i] = fn(v)
}
return result
}
// Generic Filter: keeps elements where predicate returns true
func Filter[T any](slice []T, predicate func(T) bool) []T {
var result []T
for _, v := range slice {
if predicate(v) {
result = append(result, v)
}
}
return result
}
// Generic Reduce: accumulates a value across the slice
func Reduce[T any, U any](slice []T, initial U, fn func(U, T) U) U {
acc := initial
for _, v := range slice {
acc = fn(acc, v)
}
return acc
}
func main() {
numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// Square each number
squared := Map(numbers, func(n int) int { return n * n })
fmt.Println("Squared:", squared)
// Output: Squared: [1 4 9 16 25 36 49 64 81 100]
// Keep only even numbers
evens := Filter(numbers, func(n int) bool { return n%2 == 0 })
fmt.Println("Evens:", evens)
// Output: Evens: [2 4 6 8 10]
// Sum all numbers
sum := Reduce(numbers, 0, func(acc, n int) int { return acc + n })
fmt.Println("Sum:", sum)
// Output: Sum: 55
// Compose: sum of squares of even numbers
pipeline := Reduce(
Map(
Filter(numbers, func(n int) bool { return n%2 == 0 }),
func(n int) int { return n * n },
),
0,
func(acc, n int) int { return acc + n },
)
fmt.Println("Sum of squares of evens:", pipeline)
// Output: Sum of squares of evens: 220
}
Closures and State Encapsulation
Closures are functions that capture variables from their surrounding scope. In Go, closures are powerful for creating stateful functions without exposing mutable global state. They enable the factory pattern, middleware chains, and callback-based APIs.
package main
import (
"fmt"
"strings"
)
// Create a counter generator — each call returns a new counter function
func NewCounter(start int) func() int {
count := start
return func() int {
count++
return count
}
}
// Create an accumulator with a closure
func NewAccumulator(initial int) func(int) int {
total := initial
return func(x int) int {
total += x
return total
}
}
// A greeting factory that captures a prefix
func Greeter(prefix string) func(string) string {
return func(name string) string {
return fmt.Sprintf("%s %s", prefix, name)
}
}
// Middleware chain using closures
func Logger(prefix string) func(func(int) int) func(int) int {
return func(next func(int) int) func(int) int {
return func(x int) int {
result := next(x)
fmt.Printf("%s: f(%d) = %d\n", prefix, x, result)
return result
}
}
}
func main() {
// Two independent counters
counterA := NewCounter(0)
counterB := NewCounter(100)
fmt.Println(counterA()) // 1
fmt.Println(counterA()) // 2
fmt.Println(counterB()) // 101
fmt.Println(counterB()) // 102
fmt.Println(counterA()) // 3 — state is isolated
// Accumulator
acc := NewAccumulator(10)
fmt.Println(acc(5)) // 15
fmt.Println(acc(3)) // 18
fmt.Println(acc(0)) // 18
// Greeting factory
formalGreet := Greeter("Hello, esteemed")
casualGreet := Greeter("Hey")
fmt.Println(formalGreet("Dr. Smith")) // Hello, esteemed Dr. Smith
fmt.Println(casualGreet("Alice")) // Hey Alice
// Closure-based middleware
double := func(x int) int { return x * 2 }
loggedDouble := Logger("DOUBLE")(double)
result := loggedDouble(21)
fmt.Println("Result:", result)
// Output: DOUBLE: f(21) = 42 / Result: 42
}
Pure Functions and Immutability
A pure function depends only on its explicit inputs and produces no side effects. In Go, you can enforce purity by passing copies of data or using value receivers. For slices and maps, be careful to copy before modifying to avoid mutating shared state.
package main
import "fmt"
// Pure function: same input always yields same output, no side effects
func Add(a, b int) int {
return a + b
}
// Impure version (mutates slice) vs pure version
func AppendMutate(slice []int, val int) []int {
return append(slice, val) // May mutate underlying array if capacity exists
}
func AppendPure(slice []int, val int) []int {
newSlice := make([]int, len(slice)+1)
copy(newSlice, slice)
newSlice[len(slice)] = val
return newSlice
}
// Pure struct transformation using value receiver
type Person struct {
Name string
Age int
}
// Returns a new Person instead of modifying the receiver
func (p Person) WithAge(newAge int) Person {
return Person{Name: p.Name, Age: newAge}
}
func (p Person) WithName(newName string) Person {
return Person{Name: newName, Age: p.Age}
}
// Pure slice transformation: returns new slice
func FilterInPlace[T any](slice []T, predicate func(T) bool) []T {
// Create new backing array to avoid mutating original
result := make([]T, 0, len(slice))
for _, v := range slice {
if predicate(v) {
result = append(result, v)
}
}
return result
}
func main() {
original := []int{1, 2, 3, 4, 5}
// Pure filter leaves original intact
filtered := FilterInPlace(original, func(n int) bool { return n > 3 })
fmt.Println("Original:", original) // [1 2 3 4 5]
fmt.Println("Filtered:", filtered) // [4 5]
// Pure struct transformations
john := Person{Name: "John", Age: 30}
olderJohn := john.WithAge(31).WithName("Jonathan")
fmt.Println("Original person:", john) // {John 30}
fmt.Println("Transformed person:", olderJohn) // {Jonathan 31}
}
Function Composition
Composition is combining simple functions to build complex operations. In Go, you can manually compose functions or build helper utilities to chain them. This is particularly useful in data transformation pipelines.
package main
import (
"fmt"
"strings"
)
// Compose two functions: h(x) = g(f(x))
func Compose[T, U, V any](g func(U) V, f func(T) U) func(T) V {
return func(x T) V {
return g(f(x))
}
}
// Chain multiple functions left-to-right
func Chain[T any](fns ...func(T) T) func(T) T {
return func(x T) T {
result := x
for _, fn := range fns {
result = fn(result)
}
return result
}
}
// Example functions for string processing
func trim(s string) string { return strings.TrimSpace(s) }
func lower(s string) string { return strings.ToLower(s) }
func reverse(s string) string {
runes := []rune(s)
for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
runes[i], runes[j] = runes[j], runes[i]
}
return string(runes)
}
func quote(s string) string { return fmt.Sprintf("\"%s\"", s) }
func main() {
input := " Hello World "
// Manual composition
result1 := quote(reverse(lower(trim(input))))
fmt.Println("Manual:", result1) // "dlrow olleh"
// Using Compose helper
clean := Compose(reverse, Compose(lower, trim))
result2 := quote(clean(input))
fmt.Println("Compose:", result2) // "dlrow olleh"
// Using Chain for a pipeline
pipeline := Chain(trim, lower, reverse, quote)
result3 := pipeline(input)
fmt.Println("Chain:", result3) // "dlrow olleh"
// Mathematical composition
addOne := func(x int) int { return x + 1 }
double := func(x int) int { return x * 2 }
square := func(x int) int { return x * x }
// square(double(addOne(3))) = square(double(4)) = square(8) = 64
composed := Compose(square, Compose(double, addOne))
fmt.Println("Math compose:", composed(3)) // 64
// Using Chain
mathChain := Chain(addOne, double, square)
fmt.Println("Math chain:", mathChain(3)) // 64
}
Recursion and Tail Recursion
Recursion replaces loops with self-referential function calls. Go does not optimize tail recursion, but recursive patterns are still useful for tree traversal, divide-and-conquer algorithms, and working with recursive data structures.
package main
import "fmt"
// Recursive factorial
func Factorial(n int) int {
if n <= 1 {
return 1
}
return n * Factorial(n-1)
}
// Recursive Fibonacci
func Fibonacci(n int) int {
if n <= 1 {
return n
}
return Fibonacci(n-1) + Fibonacci(n-2)
}
// Tail-recursive factorial (manually trampolined for Go)
func FactorialTail(n int) int {
return factHelper(n, 1)
}
func factHelper(n, acc int) int {
if n <= 1 {
return acc
}
return factHelper(n-1, acc*n)
}
// Recursive tree traversal
type TreeNode struct {
Value int
Left *TreeNode
Right *TreeNode
}
func SumTree(node *TreeNode) int {
if node == nil {
return 0
}
return node.Value + SumTree(node.Left) + SumTree(node.Right)
}
// Map over a tree recursively
func MapTree(node *TreeNode, fn func(int) int) *TreeNode {
if node == nil {
return nil
}
return &TreeNode{
Value: fn(node.Value),
Left: MapTree(node.Left, fn),
Right: MapTree(node.Right, fn),
}
}
// Depth-first traversal with accumulator
func CollectValues(node *TreeNode, acc *[]int) {
if node == nil {
return
}
*acc = append(*acc, node.Value)
CollectValues(node.Left, acc)
CollectValues(node.Right, acc)
}
func main() {
fmt.Println("Factorial 5:", Factorial(5)) // 120
fmt.Println("Tail Factorial 5:", FactorialTail(5)) // 120
fmt.Println("Fibonacci 10:", Fibonacci(10)) // 55
// Build a tree
root := &TreeNode{
Value: 1,
Left: &TreeNode{Value: 2, Left: &TreeNode{Value: 3}},
Right: &TreeNode{Value: 4, Right: &TreeNode{Value: 5}},
}
fmt.Println("Tree sum:", SumTree(root)) // 1+2+3+4+5 = 15
doubledTree := MapTree(root, func(x int) int { return x * 2 })
fmt.Println("Doubled tree sum:", SumTree(doubledTree)) // 30
var values []int
CollectValues(root, &values)
fmt.Println("All values:", values) // [1 2 3 4 5]
}
Option Types and Error Handling
Functional programming prefers explicit error handling via types rather than exceptions. In Go, the idiomatic error return pattern already mirrors the Result or Option types from functional languages. You can wrap this pattern into reusable types.
package main
import (
"errors"
"fmt"
"strconv"
)
// Result type that holds either a value or an error
type Result[T any] struct {
value T
err error
}
func Success[T any](val T) Result[T] {
return Result[T]{value: val, err: nil}
}
func Failure[T any](err error) Result[T] {
var zero T
return Result[T]{value: zero, err: err}
}
func (r Result[T]) IsOk() bool { return r.err == nil }
func (r Result[T]) Unwrap() T {
if r.err != nil {
panic(fmt.Sprintf("unwrap on error: %v", r.err))
}
return r.value
}
func (r Result[T]) UnwrapOr(defaultVal T) T {
if r.err != nil {
return defaultVal
}
return r.value
}
// Map over a Result (transform the value if Ok)
func MapResult[T, U any](r Result[T], fn func(T) U) Result[U] {
if r.err != nil {
return Result[U]{err: r.err}
}
return Result[U]{value: fn(r.value)}
}
// Chain Results with a function that itself returns a Result
func FlatMapResult[T, U any](r Result[T], fn func(T) Result[U]) Result[U] {
if r.err != nil {
return Result[U]{err: r.err}
}
return fn(r.value)
}
func parseInt(s string) Result[int] {
n, err := strconv.Atoi(s)
if err != nil {
return Failure[int](fmt.Errorf("parse error: %w", err))
}
return Success(n)
}
func reciprocal(n int) Result[float64] {
if n == 0 {
return Failure[float64](errors.New("division by zero"))
}
return Success(1.0 / float64(n))
}
func main() {
// Successful pipeline
result := FlatMapResult(
FlatMapResult(parseInt("10"), reciprocal),
func(f float64) Result[string] {
return Success(fmt.Sprintf("%.2f", f))
},
)
if result.IsOk() {
fmt.Println("Success:", result.Unwrap()) // 0.10
} else {
fmt.Println("Error:", result.err)
}
// Handling failures gracefully
r1 := parseInt("invalid")
fmt.Println("UnwrapOr:", r1.UnwrapOr(0)) // 0 (default)
r2 := reciprocal(0)
fmt.Println("Reciprocal of 0 error:", r2.err) // division by zero
// Map over success
mapped := MapResult(parseInt("42"), func(n int) string {
return fmt.Sprintf("Answer: %d", n)
})
fmt.Println("Mapped:", mapped.UnwrapOr("")) // Answer: 42
}
Advanced Patterns
Currying and Partial Application
Currying transforms a function taking multiple arguments into a chain of single-argument functions. Partial application fixes some arguments in advance. In Go, you can achieve this manually with closures.
package main
import "fmt"
// Original: func(int, int, int) int
func add3(a, b, c int) int {
return a + b + c
}
// Curried version returning successive functions
func CurriedAdd3(a int) func(int) func(int) int {
return func(b int) func(int) int {
return func(c int) int {
return a + b + c
}
}
}
// Partial application using closures
func PartialAdd(a int) func(int, int) int {
return func(b, c int) int {
return a + b + c
}
}
// Generic curry helper for 2-argument functions
func Curry2[T, U, V any](fn func(T, U) V) func(T) func(U) V {
return func(t T) func(U) V {
return func(u U) V {
return fn(t, u)
}
}
}
func main() {
// Curried invocation
result1 := CurriedAdd3(1)(2)(3)
fmt.Println("Curried:", result1) // 6
// Partial application
addOne := PartialAdd(1)
result2 := addOne(2, 3)
fmt.Println("Partial:", result2) // 6
// Reusable curried function
multiply := func(a, b int) int { return a * b }
curriedMul := Curry2(multiply)
double := curriedMul(2)
triple := curriedMul(3)
fmt.Println("Double 10:", double(10)) // 20
fmt.Println("Triple 10:", triple(10)) // 30
// Building specialized functions
format := func(prefix, name, suffix string) string {
return prefix + name + suffix
}
greet := func(prefix string) func(string) func(string) string {
return func(name string) func(string) string {
return func(suffix string) string {
return prefix + name + suffix
}
}
}
formalGreeting := greet("Dear ")("Alice")(",\n")
casualGreeting := greet("Hey ")("Bob")("!")
fmt.Print(formalGreeting) // Dear Alice,
fmt.Print(casualGreeting) // Hey Bob!
}
Lazy Evaluation with Closures
Go evaluates arguments eagerly, but you can simulate laziness by wrapping computations in closures (thunks). This defers execution until explicitly called, which is useful for expensive computations or infinite sequences.
package main
import "fmt"
// Thunk: a deferred computation
type Thunk[T any] func() T
// Create a thunk from a value (already evaluated)
func FromValue[T any](val T) Thunk[T] {
return func() T { return val }
}
// Create a thunk that computes lazily
func Lazy[T any](compute func() T) Thunk[T] {
cached := false
var result T
return func() T {
if !cached {
result = compute()
cached = true
}
return result
}
}
// Map over a thunk (lazy map)
func MapThunk[T, U any](t Thunk[T], fn func(T) U) Thunk[U] {
return func() U {
return fn(t())
}
}
// Infinite sequence using thunks
type LazyList[T any] struct {
head T
tail Thunk[*LazyList[T]]
}
func FromSlice[T any](items []T) *LazyList[T] {
if len(items) == 0 {
return nil
}
return &LazyList[T]{
head: items[0],
tail: Lazy(func() *LazyList[T] {
return FromSlice(items[1:])
}),
}
}
func Take[T any](list *LazyList[T], n int) []T {
var result []T
current := list
for i := 0; i < n && current != nil; i++ {
result = append(result, current.head)
if current.tail != nil {
current = current.tail()
} else {
break
}
}
return result
}
func main() {
// Lazy computation of an expensive operation
expensiveCalculation := Lazy(func() int {
fmt.Println("Computing...")
// Simulate heavy computation
sum := 0
for i := 1; i <= 1000000; i++ {
sum += i
}
return sum
})
fmt.Println("Thunk created, not yet evaluated")
// Nothing printed yet
result := expensiveCalculation() // Triggers computation
fmt.Println("First call result:", result)
// "Computing..." printed, then result
result2 := expensiveCalculation() // Uses cached value
fmt.Println("Second call result:", result2)
// No "Computing..." printed — cached
// Lazy list: infinite-like sequence
nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
lazyNums := FromSlice(nums)
// Take only first 5 elements
first5 := Take(lazyNums, 5)
fmt.Println("First 5:", first5) // [1 2 3 4 5]
// Take more
first10 := Take(lazyNums, 10)
fmt.Println("First 10:", first10) // [1 2 3 4 5 6 7 8 9 10]
}
Best Practices
- Prefer pure functions where possible — isolate side effects (I/O, database calls, HTTP requests) to the boundaries of your application. Keep core business logic pure.
- Use value types for immutability — pass structs by value or return new instances instead of modifying pointers. Use
copy()for slices you intend to transform. - Leverage Go's error returns — they already embody the functional
Resultpattern. Don't panic in libraries; return errors and let callers decide. - Keep functions small and named — a function should do one thing. Name it clearly. If you're passing anonymous functions, keep them short; extract complex ones.
- Use function types for documentation —
type Transformer func(int) intcommunicates intent better than a raw function signature. - Don't over-abstract — Go values simplicity. Not every loop needs to become a
Mapcall. Use higher-order functions when they genuinely improve clarity. - Beware of performance — recursion without tail-call optimization can overflow the stack. Closures allocate memory. Profile before optimizing functional abstractions in hot paths.
- Embrace interfaces alongside functions — Go's interfaces enable polymorphic behavior that complements functional patterns. A function can accept an interface and return concrete values.
- Document closure behavior — closures that capture mutable variables can surprise readers. Clearly document what state a returned function captures and modifies.
- Combine with Go's concurrency model — pure functions are inherently goroutine-safe. Pass immutable data through channels and process it with stateless functions for naturally concurrent pipelines.
Real-World Example: Functional Data Pipeline
Here is a complete example combining multiple functional techniques to build a data processing pipeline — typical of what you might find in a production Go service.
package main
import (
"bufio"
"fmt"
"os"
"strings"
)
// Pure transformation functions
func normalize(word string) string {
return strings.ToLower(strings.TrimSpace(word))
}
func isStopWord(word string) bool {
stopWords := map[string]bool{
"the": true, "a": true, "an": true, "is": true,
"of": true, "and": true, "in": true, "to": true,
"it": true, "for": true,
}
return stopWords[word]
}
func isNotEmpty(s string) bool { return len(s) > 0 }
// Pipeline stages
func splitIntoWords(line string) []string {
return strings.Fields(line)
}
func removeStopWords(words []string) []string {
return Filter(words, func(w string) bool {
return !isStopWord(w)
})
}
func normalizeWords(words []string) []string {
return Map(words, normalize)
}
func filterEmpty(words []string) []string {
return Filter(words, isNotEmpty)
}
// Count word frequencies using immutable accumulator
func countFrequencies(words []string) map[string]int {
frequencies := make(map[string]int)
for _, w := range words {
frequencies[w]++
}
return frequencies
}
// Merge two frequency maps (pure function)
func mergeFrequencies(a, b map[string]int) map[string]int {
result := make(map[string]int)
for k, v := range a {
result[k] = v
}
for k, v := range b {
result[k] += v
}
return result
}
// Generic functions (defined earlier; included for completeness)
func Map[T any, U any](slice []T, fn func(T) U) []U {
result := make([]U, len(slice))
for i, v := range slice {
result[i] = fn(v)
}
return result
}
func Filter[T any](slice []T, predicate func(T) bool) []T {
var result []T
for _, v := range slice {
if predicate(v) {
result = append(result, v)
}
}
return result
}
func Reduce[T any, U any](slice []T, initial U, fn func(U, T) U) U {
acc := initial
for _, v := range slice {
acc = fn(acc, v)
}
return acc
}
func main() {
// Sample text
text := `Go is a language that makes concurrency easy.
Functional programming in Go is not about purity but about composability.
Go makes it easy to write concurrent programs that are correct and maintainable.`
lines := strings.Split(text, "\n")
// Build a functional pipeline for each line, then merge results
totalFrequencies := Reduce(lines, map[string]int{}, func(acc map[string]int, line string) map[string]int {
// Compose the pipeline for a single line
processed := filterEmpty(
normalizeWords(
removeStopWords(
splitIntoWords(line),
),
),
)
lineFreqs := countFrequencies(processed)
return mergeFrequencies(acc, lineFreqs)
})
fmt.Println("Word frequencies (excluding stop words):")
for word, count := range totalFrequencies {
fmt.Printf(" %s: %d\n", word, count)
}
}
Functional Options Pattern
The functional options pattern is a classic Go idiom that uses higher-order functions to configure complex constructors cleanly. It's a prime example of functional programming in idiomatic Go.
package main
import (
"fmt"
"time"
)
// ServerConfig holds configuration for a server
type ServerConfig struct {
host string
port int
timeout time.Duration
maxConn int
enableLogs bool
}
// Option is a functional option: it modifies a ServerConfig
type Option func(*ServerConfig)
// WithHost sets the host
func WithHost(host string) Option {
return func(cfg *ServerConfig) {
cfg.host = host
}
}
// WithPort sets the port
func WithPort(port int) Option {
return func(cfg *ServerConfig) {
cfg.port = port
}
}
// WithTimeout sets the timeout
func WithTimeout(d time.Duration) Option {
return func(cfg *ServerConfig) {
cfg.timeout = d
}
}
// WithMaxConnections sets max connections
func WithMaxConnections(n int) Option {
return func(cfg *ServerConfig) {
cfg.maxConn = n
}
}
// WithLogging enables or disables logging
func WithLogging(enabled bool) Option {
return func(cfg *ServerConfig) {
cfg.enableLogs = enabled
}
}
// NewServer creates a server with the given options
func NewServer(options ...Option) *ServerConfig {
// Sensible defaults
cfg := &ServerConfig{
host: "localhost",
port: 8080,
timeout: 30 * time.Second,
maxConn: 100,
enableLogs: false,
}
// Apply each option function
for _, opt := range options {
opt(cfg)
}
return cfg
}
func main() {
// Configure server with functional options
server := NewServer(
WithHost("0.0.0.0"),
WithPort(9090),
WithTimeout(10*time.Second),
WithMaxConnections(500),
WithLogging(true),
)
fmt.Printf("Server config: %+v\n", server)
// Output: &{host:0.0.0.0 port:9090 timeout:10s maxConn:500 enableLogs:true}
// Minimal configuration
defaultServer := NewServer()
fmt.Printf("Default config: %+v\n", defaultServer)
// Output: &{host:localhost port:8080 timeout:30s maxConn:100 enableLogs:false}
// Partial override
customServer := NewServer(
WithPort(3000),
WithLogging(true),
)
fmt.Printf("Custom config: %+v\n", customServer)
// Output: &{host:localhost port:3000 timeout:30s maxConn:100 enableLogs:true}
}
Conclusion
Functional programming in Go is not about rigidly adhering to academic purity — it's about selectively applying functional principles to write clearer, safer, and more composable code. Go's first-class functions, closures, and value-type semantics provide a solid foundation for functional patterns without sacrificing the language's core strengths: simplicity, performance, and explicit error handling. By combining pure functions for business logic, higher-order functions for reusable abstractions, immutability for concurrency safety, and the functional options pattern for clean configuration, you can build Go applications that are easier to test, reason about, and maintain. The key is balance: apply functional techniques where they add clarity, and fall back on Go's imperative strengths where they don't. With the arrival of generics in Go 1.18, reusable functional combinators like Map,