
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.

Multiple Return Values


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 method is a function with a receiver - a named type that the function is bound to. Any named type (not just structs) can have methods. Methods are how Go expresses behaviour.

<ExamplePair>
<ExampleProse>

Declare a method by placing the receiver before the function name. A value receiver operates on a copy - mutations do not affect the original. A pointer receiver operates on the original - mutations persist.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

type Rectangle struct {
    Width, Height float64
}

// Value receiver - read-only, works on a copy
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// Value receiver - read-only
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// Pointer receiver - mutates the original
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

func main() {
    rect := Rectangle{Width: 10, Height: 5}
    fmt.Println(rect.Area())      // 50
    fmt.Println(rect.Perimeter()) // 30

    rect.Scale(2)
    fmt.Println(rect.Area()) // 200 - Width and Height were mutated
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Go interfaces are satisfied implicitly - there is no `implements` keyword. If a type has all the methods an interface requires, it satisfies the interface automatically. This allows adapters to be written without modifying the original type.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "math"
)

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func printArea(s Shape) {
    fmt.Printf("%.2f\n", s.Area())
}

func main() {
    // Both satisfy Shape without any explicit declaration
    printArea(Circle{Radius: 5})        // 78.54
    printArea(Rectangle{Width: 4, Height: 6}) // 24.00
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Because interface satisfaction is implicit, a typo in a method signature silently drops the satisfaction - no compile error. Add a compile-time assertion to catch this immediately.

</ExampleProse>
<ExampleCode>

```go
package main

type Writer interface {
    Write(p []byte) (n int, err error)
}

type MyWriter struct{}

func (w *MyWriter) Write(p []byte) (int, error) {
    return len(p), nil
}

// Compile-time check: if *MyWriter stops satisfying Writer,
// this line produces a compile error immediately.
var _ Writer = (*MyWriter)(nil)

func main() {
    var w Writer = &MyWriter{}
    n, _ := w.Write([]byte("hello"))
    _ = n
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Go interfaces are satisfied implicitly - this is powerful (write an adapter for any third-party type without modifying it) and risky (a one-character typo in a method name silently drops interface satisfaction). The `var _ SomeInterface = (*MyType)(nil)` pattern adds a zero-cost compile-time assertion that produces a clear error the moment the interface is broken. Add one of these assertions in the file where the type is declared - not in a test file - so it is always compiled, not just when tests run. This pattern is especially important for interfaces that are checked at runtime (HTTP handlers, database drivers, event consumers) where a missed satisfaction surfaces as a nil-dereference panic at request time rather than a compile error.
</InProduction>


Method declaration, pointer vs value receivers, method sets, and implicit interface satisfaction.