Functions

A Go function can return several values at once, idiomatically a (T, error) pair returned as return val, err. You can also name the results: named results are pre-declared variables that start at their zero value and stay in scope for the whole body, enabling a naked return that sends back their current values. The caller must read every returned value or discard one with _.

First-class means a function is an ordinary value: you can assign it to a variable, pass it as an argument, and return it from another function. Each function has a function type like func(int) int describing its parameters and results, so the compiler type-checks these uses. You can also write an anonymous function inline, with no name.

Writing ...T on the last parameter makes a function variadic: it collects any number of trailing arguments into a []T slice, so inside the body the parameter is an ordinary slice you can range over. You call it with separate args like f(a, b, c), or spread an existing slice with f(s...). Standard functions such as append and fmt.Println are variadic this way.

Recursion is a function that calls itself, and it needs a base case that returns without recursing so the chain terminates. Go does NOT guarantee tail-call optimization, so even a tail-recursive call adds a new frame: each level consumes more of the goroutine stack, which grows but can eventually overflow. Because of this, an explicit loop is preferred for hot or very deep paths.

Named results are real variables that stay in scope until the function actually returns, even after a return statement has set them. A deferred closure — itself a first-class function value — runs in that window, so it can read and reassign them: defer func(){ err = wrap(err) }() overwrites what the caller receives. This is impossible with unnamed returns, since no variable is left for the deferred call to touch.