Golang Functions: Declaring, Calling and Passing Functions

Declaring a function

A function declaration is func, a name, the parameters, the result type, and a body. The type goes after the parameter name, not before it.

package main

import "fmt"

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

func greet(name string) {
	fmt.Println("Hello,", name)
}

func main() {
	sum := add(3, 4)
	fmt.Println(sum)
	greet("Gopher")
}

add takes two int values and returns an int. greet returns nothing, so its signature has no result type and its body needs no return.

A function that declares a result must end in a terminating statement. If some path can reach the closing brace without returning, the compiler stops with missing return.

Parameters that share a type

Consecutive parameters of the same type can share one type name. func add(a, b int) int means exactly the same as func add(a int, b int) int. Mixing is allowed too:

func scale(x, y float64, factor int) (float64, float64)

Here x and y are float64 and factor is an int.

Return values

A function can return zero, one, or several values. Several results go in parentheses, and the caller receives them with a multiple assignment:

package main

import "fmt"

func divmod(a, b int) (int, int) {
	return a / b, a % b
}

func main() {
	q, r := divmod(17, 5)
	fmt.Println(q, r)
}

This prints 3 2. The (value, error) pair is the most common use of this feature in Go, and it has its own page on multiple return values.

Arguments are copied

Go passes every argument by value. The function works on a copy, so assigning to a parameter never changes the caller's variable.

package main

import "fmt"

type Point struct{ X, Y int }

func moveCopy(p Point) {
	p.X = 100
}

func movePtr(p *Point) {
	p.X = 100
}

func fillFirst(s []int) {
	s[0] = 99
}

func main() {
	p := Point{1, 2}
	moveCopy(p)
	fmt.Println(p) // unchanged

	movePtr(&p)
	fmt.Println(p) // changed through the pointer

	nums := []int{1, 2, 3}
	fillFirst(nums)
	fmt.Println(nums) // the slice header was copied, the elements were not
}

The output is:

{1 2}
{100 2}
[99 2 3]

The third line surprises people. A slice value is a small header (pointer, length, capacity). The copy points at the same backing array, so writing s[0] writes the caller's element. But append inside the function may allocate a new array, and the caller never sees that new header. If a function grows a slice, return the new slice. The same logic applies to maps: the function can add keys the caller sees, because the map value refers to shared data.

Use a pointer parameter when the function must modify the caller's variable, or when the value is a large struct you do not want to copy on every call.

Functions are values

A function has a type, written without the name: func(int, int) int. You can store a function in a variable, put it in a map or slice, and pass it to another function.

package main

import (
	"fmt"
	"strings"
)

func apply(xs []int, f func(int) int) []int {
	out := make([]int, 0, len(xs))
	for _, x := range xs {
		out = append(out, f(x))
	}
	return out
}

func double(n int) int { return n * 2 }

func main() {
	fmt.Println(apply([]int{1, 2, 3}, double))

	square := func(n int) int { return n * n }
	fmt.Println(apply([]int{1, 2, 3}, square))

	ops := map[string]func(string) string{
		"upper": strings.ToUpper,
		"lower": strings.ToLower,
	}
	fmt.Println(ops["upper"]("go"), ops["lower"]("GO"))
}

square is an anonymous function assigned to a variable. Anonymous functions can also read and change variables from the surrounding scope, which makes them closures.

A named function type makes signatures easier to read when the same shape appears in many places:

type Transform func(int) int

func apply(xs []int, f Transform) []int

The zero value of a function type is nil. Calling a nil function panics with invalid memory address or nil pointer dereference, so check optional callbacks before calling them. Function values can only be compared to nil, never to each other.

Recursion

A function can call itself. Go has no tail-call optimization, but goroutine stacks grow on demand, so ordinary recursion depths are fine.

package main

import "fmt"

func factorial(n int) int {
	if n <= 1 {
		return 1
	}
	return n * factorial(n-1)
}

func main() {
	for i := range 6 {
		fmt.Println(i, factorial(i))
	}
}

for i := range 6 counts from 0 to 5 and needs Go 1.22 or later.

What Go functions do not have

• No overloading. Two functions in one package cannot share a name, even with different parameters.
• No default or named arguments. Every parameter is passed at every call, in order. A config struct gives you named, optional fields: NewServer(Config{Port: 8080}).
• No nested named functions. Inside a function body you can only declare anonymous functions, usually assigned to a variable.

Variable-length argument lists are supported through variadic functions.

Exported and unexported functions

A function whose name starts with an uppercase letter (Parse) is exported and callable from other packages. A lowercase name (parse) is visible only inside its own package. There are no public or private keywords; capitalization is the whole rule.

Common mistakes

• Expecting a parameter change to reach the caller. Assigning to a parameter only changes the copy. Return the new value or take a pointer.
• Appending inside a function and ignoring the result. func add(s []int) { s = append(s, 1) } has no effect on the caller's slice length. Write func add(s []int) []int and use s = add(s).
• Unused results. Go allows ignoring a return value. go vet does not flag a dropped error, but linters such as errcheck (part of golangci-lint) do. Use _ = only when ignoring is a decision.