
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.

Variadic Functions


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


Go functions can return any number of values. The most common form is the `(result, error)` pair - a pattern that shows up in virtually every Go program and standard library call.

<ExamplePair>
<ExampleProse>

Declare multiple return types in parentheses. The caller receives all returned values and must handle each one - there is no implicit discard.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "errors"
    "fmt"
)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 3)
    if err != nil {
        fmt.Println("error:", err)
        return
    }
    fmt.Printf("%.4f\n", result) // 3.3333
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Use the blank identifier `_` to discard a return value you don't need. This is idiomatic when you are certain an error cannot occur, or when you deliberately do not need the second value.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "strconv"
)

func minMax(nums []int) (int, int) {
    min, max := nums[0], nums[0]
    for _, n := range nums[1:] {
        if n < min {
            min = n
        }
        if n > max {
            max = n
        }
    }
    return min, max
}

func main() {
    nums := []int{3, 1, 4, 1, 5, 9, 2, 6}
    min, max := minMax(nums)
    fmt.Println(min, max) // 1 9

    // Discard the error when input is a known constant
    n, _ := strconv.Atoi("42")
    fmt.Println(n) // 42
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Named return values give the return variables names in the signature. They are initialized to zero values and can be returned with a bare `return`. Use named returns for short functions where the names clarify intent.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

// Named returns document what each value represents
func stats(nums []float64) (mean, variance float64) {
    n := float64(len(nums))
    for _, v := range nums {
        mean += v
    }
    mean /= n
    for _, v := range nums {
        d := v - mean
        variance += d * d
    }
    variance /= n
    return // naked return - only acceptable in short functions
}

func main() {
    m, v := stats([]float64{2, 4, 4, 4, 5, 5, 7, 9})
    fmt.Printf("mean=%.2f variance=%.2f\n", m, v) // mean=5.00 variance=4.00
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Returning `(value, error)` is the mechanism behind idiomatic Go error handling - it forces callers to decide what to do at every call site rather than letting errors propagate implicitly. Named return values are fine as documentation at the top of a short function, but naked returns in long functions hurt readability: during an incident you have to scroll back to the signature to understand what is being returned. Prefer explicit returns in all but the shortest helpers. Never use output parameters (pointer arguments as return slots) as a substitute for multiple returns - they obscure the function's contract and break the idiomatic call style.
</InProduction>


Go functions can return more than one value - the canonical pattern is returning a result alongside an error.