
A recursive function calls itself until it reaches a base case. Go supports recursion with automatically growing goroutine stacks - you do not need to worry about a fixed stack size as you would in C.

<ExamplePair>
<ExampleProse>

Classic factorial: the base case returns immediately; the recursive case reduces the problem by one step each call.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func factorial(n int) int {
    if n == 0 {
        return 1 // base case
    }
    return n * factorial(n-1)
}

func main() {
    fmt.Println(factorial(5))  // 120
    fmt.Println(factorial(10)) // 3628800
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Two functions can call each other mutually. Go resolves the forward reference at link time, so you only need to declare both functions in the same package.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func isEven(n int) bool {
    if n == 0 {
        return true
    }
    return isOdd(n - 1)
}

func isOdd(n int) bool {
    if n == 0 {
        return false
    }
    return isEven(n - 1)
}

func main() {
    fmt.Println(isEven(8)) // true
    fmt.Println(isOdd(7))  // true
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

A closure can refer to itself by assigning it to a variable before the function literal is called.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    var fib func(n int) int
    fib = func(n int) int {
        if n <= 1 {
            return n
        }
        return fib(n-1) + fib(n-2)
    }

    for i := 0; i < 8; i++ {
        fmt.Printf("fib(%d) = %d\n", i, fib(i))
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Go does not optimize tail calls - every recursive call adds a frame to the goroutine's stack. Go grows that stack automatically up to a configurable limit (default 1 GB) before panicking with a stack overflow. For deep traversal - parsing deeply nested JSON, walking large directory trees, traversing binary trees with millions of nodes - an explicit stack (a slice used as a LIFO queue) is more predictable: you control memory usage, avoid GC pressure from many small frames, and can apply a depth limit cleanly. Save recursion for cases where the problem depth is bounded and the recursive form is substantially clearer.
</InProduction>


Functions that call themselves - Go supports recursion with automatic goroutine stack growth, though deep trees are better handled with an explicit stack.

Recursion


`range` is Go's universal iteration keyword. It adapts to the type it ranges over: slices give index and value, maps give key and value, strings give byte-index and rune, channels give values as they arrive, and since Go 1.22 integers give a count from 0.

<ExamplePair>
<ExampleProse>

Ranging over a slice yields the index and a copy of the element. Use `_` to discard whichever you don't need.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    fruits := []string{"apple", "banana", "cherry"}

    for i, v := range fruits {
        fmt.Println(i, v)
    }
    // 0 apple
    // 1 banana
    // 2 cherry

    // Index only
    for i := range fruits {
        fmt.Println(i)
    }

    // Value only
    for _, v := range fruits {
        fmt.Println(v)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Ranging over a map yields key-value pairs. Map iteration order is deliberately randomised by the runtime on each run.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "sort"
)

func main() {
    scores := map[string]int{"alice": 90, "bob": 85, "carol": 92}

    // Order is non-deterministic
    for name, score := range scores {
        fmt.Printf("%s: %d\n", name, score)
    }

    // Deterministic output - sort keys first
    keys := make([]string, 0, len(scores))
    for k := range scores {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    for _, k := range keys {
        fmt.Printf("%s: %d\n", k, scores[k])
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Ranging over a string decodes UTF-8 runes, not bytes. The index is the byte offset of the rune in the string, not its position in a character array.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    s := "héllo"

    // range gives (byte-index, rune)
    for i, r := range s {
        fmt.Printf("index=%d rune=%c\n", i, r)
    }
    // index=0 rune=h
    // index=1 rune=é  (é is 2 bytes in UTF-8)
    // index=3 rune=l
    // index=4 rune=l
    // index=5 rune=o

    fmt.Println(len(s))         // 6 - byte length
    fmt.Println(len([]rune(s))) // 5 - rune (character) count
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Since Go 1.22, you can range over an integer `n` to iterate from `0` to `n-1` - a concise replacement for `for i := 0; i < n; i++`.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    // Go 1.22+: range over integer
    for i := range 5 {
        fmt.Println(i)
    }
    // 0 1 2 3 4
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Two surprises appear constantly in code review. First, map iteration order is non-deterministic - if you need deterministic output (logs, serialized responses, test assertions), sort the keys explicitly before ranging. Second, ranging over a string decodes UTF-8 runes, so the index jumps by byte width, not by 1. `len(s)` returns bytes; `len([]rune(s))` returns rune count. Mixing these silently corrupts string operations on any non-ASCII input - a bug that only surfaces when users with non-Latin names or emoji-heavy data start using your product.
</InProduction>


The range keyword iterates over slices, maps, strings, channels, and integers - each with different iteration semantics worth knowing.

Range over Built-in Types


A variadic function accepts zero or more arguments for its last parameter by prefixing the type with `...`. Inside the function the variadic parameter is a slice. The `...` spread operator passes an existing slice as separate arguments.

<ExamplePair>
<ExampleProse>

Declare the last parameter with `...T`. The caller can pass any number of values of that type, including none. Inside the function, the parameter behaves as a `[]T`.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

func main() {
    fmt.Println(sum())           // 0
    fmt.Println(sum(1, 2, 3))   // 6
    fmt.Println(sum(1, 2, 3, 4, 5)) // 15
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Spread an existing slice into a variadic call with `s...`. The function receives the slice's elements as individual arguments.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

func main() {
    nums := []int{10, 20, 30}
    fmt.Println(sum(nums...)) // 60

    // Mix fixed and variadic parameters
    fmt.Println(sum(1, 2, 3)) // 6
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Variadic functions can be combined with fixed parameters. Only the last parameter can be variadic.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func logMessage(level string, parts ...string) {
    fmt.Printf("[%s]", level)
    for _, p := range parts {
        fmt.Printf(" %s", p)
    }
    fmt.Println()
}

func main() {
    logMessage("INFO", "server", "started", "on", ":8080")
    // [INFO] server started on :8080

    logMessage("WARN") // variadic part is empty - that is fine
    // [WARN]
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Watch for accidental slice aliasing when passing a slice with `s...` - the function receives the same backing array. If the callee appends to the variadic parameter, it may silently clobber the caller's data when the slice still has capacity. Prefer an explicit `[]T` parameter when the function might mutate or extend the slice. Variadic functions enable ergonomic APIs (`fmt.Println`, `append`) but they are not magic - they are syntactic sugar over a slice. Passing a large slice with `s...` is no more or less efficient than passing it directly.
</InProduction>


A variadic function accepts a variable number of arguments via the ...T parameter - the basis of fmt.Println, append, and ergonomic APIs.