Functions

Basic syntax

func add(a int, b int) int {
  return a + b
}

// shared type for adjacent parameters
func multiply(a, b int) int {
  return a * b
}

Multiple return values

This is one of Go’s most distinctive features, and it’s the foundation of Go’s error handling:

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

▶ Run

Callers are expected to check the error immediately — the compiler won’t stop you from ignoring it, but go vet and linters like errcheck will flag it.

Named return values

func split(sum int) (x, y int) {
  x = sum * 4 / 9
  y = sum - x
  return // "naked" return — returns x and y
}

Useful for documenting what a function returns, but use sparingly — it can make longer functions harder to follow.

Variadic functions

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

sum(1, 2, 3)       // 6
sum([]int{4, 5}...) // spread a slice

Functions as values, and closures

Functions are first-class values in Go — you can pass them around and close over local variables:

func makeCounter() func() int {
  count := 0
  return func() int {
    count++
    return count
  }
}

counter := makeCounter()
counter() // 1
counter() // 2

Each call to makeCounter produces an independent counter, because each closure captures its own count.

Use case

Middleware in HTTP servers is just a function that wraps a http.HandlerFunc and returns another one:

func withLogging(next http.HandlerFunc) http.HandlerFunc {
  return func(w http.ResponseWriter, r *http.Request) {
    log.Println(r.Method, r.URL.Path)
    next(w, r)
  }
}

http.HandleFunc("/", withLogging(homeHandler))

Chaining several of these (auth, logging, rate limiting) is how most Go web frameworks build request pipelines.