Functions in Go

//  ↓ keyword  ↓ name   ↓ parameters      ↓ return type
func divide  (a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("divide by zero")
    }
    return a / b, nil
}

// Single return
func square(x int) int {
    return x * x
}
 
// Multiple returns — idiomatic Go
func divide(a, b int) (int, error) {
    if b == 0 { return 0, fmt.Errorf("divide by zero") }
    return a / b, nil
}
 
// Named returns — use sparingly, good for short functions
func minMax(nums []int) (min, max int) {
    min, max = nums[0], nums[0]
    for _, n := range nums[1:] {
        if n < min { min = n }
        if n > max { max = n }
    }
    return // naked return — returns min and max
}

// Assign to variable
greet := func(name string) string {
    return "Hello, " + name
}
fmt.Println(greet("Go")) // Hello, Go
 
// Pass as argument (higher-order function)
func apply(x int, fn func(int) int) int {
    return fn(x)
}
fmt.Println(apply(5, func(n int) int { return n * 2 })) // 10
 
// Return a function (factory / closure)
func multiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}
double := multiplier(2)
fmt.Println(double(7)) // 14

func counter() func() int {
    count := 0
    return func() int {
        count++ // count lives on the heap — shared with the closure
        return count
    }
}
 
c := counter()
fmt.Println(c()) // 1
fmt.Println(c()) // 2
fmt.Println(c()) // 3
 
c2 := counter() // independent counter
fmt.Println(c2()) // 1

// Anonymous function assigned to a variable
square := func(x int) int { return x * x }
fmt.Println(square(4)) // 16
 
// IIFE — declared and called immediately
result := func(a, b int) int {
    return a + b
}(10, 5)
fmt.Println(result) // 15
 
// Common use: goroutine IIFE
go func(msg string) {
    fmt.Println(msg)
}("hello from goroutine")

func readFile(path string) error {
    f, err := os.Open(path)
    if err != nil { return err }
    defer f.Close() // ✅ guaranteed to run even if function panics
 
    // ... read file
    return nil
}

// Defers run LIFO
defer fmt.Println("third")
defer fmt.Println("second")
defer fmt.Println("first")
// Output: first → second → third

func init() {
    // runs automatically before main()
    // no parameters, no return value
}

var db *sql.DB
 
func init() {
    var err error
    db, err = sql.Open("postgres", os.Getenv("DB_URL"))
    if err != nil {
        log.Fatal(err)
    }
}

func factorial(n int) int {
    if n == 0 { return 1 }
    return n * factorial(n-1)
}
 
// With memoization (production pattern)
var memo = map[int]int{}
func fib(n int) int {
    if n <= 1 { return n }
    if v, ok := memo[n]; ok { return v }
    memo[n] = fib(n-1) + fib(n-2)
    return memo[n]
}

// Define a function type
type Transformer func(int) int
 
func applyAll(nums []int, fns ...Transformer) []int {
    result := make([]int, len(nums))
    copy(result, nums)
    for _, fn := range fns {
        for i, v := range result {
            result[i] = fn(v)
        }
    }
    return result
}
 
double := Transformer(func(x int) int { return x * 2 })
addOne := Transformer(func(x int) int { return x + 1 })
fmt.Println(applyAll([]int{1, 2, 3}, double, addOne)) // [3 5 7]