Go Anonymous Function

Sometimes, when writing a program, we want to define a small function that is only going to be used once (for example, as a parameter to a sorting function). In such a case, it would add unnecessary clutter to the program to give the function a name, we rather want to define it as a lambda, that is, an anonymous function.

Syntax of anonymous functions

The syntax of an anonymous function is as follows:

func (parameters) (returnType) {
	// function body
}

It is similar to the syntax of a normal function, except that there is no identifier after the func keyword.

Iterate a function a certain number of times

As an example, let's consider a function that takes three arguments:

• an integer x,
• a function f that takes an integer as an argument and returns an integer,
• an integer n: the number of times we want to apply f to x.

In Go,

func iterate(x int, f func(int) int, n int) int {
	for i := 0; i < n; i++ {
		x = f(x)
	}
	return x
}

Now, we can use an anonymous function as the second argument to iterate:

func main() {
	fmt.Println(iterate(2, func(x int) int { return x * x }, 3))
}

This snippet prints 256 (that is ((2^2)^2)^2).

Sort an array of integers given a comparison function

A more realistic example is to sort an array of integers given a comparison function. As above, we start by defining a function that takes another function as an argument:

func sort(a []int, less func(int, int) bool) {
	for i, _ := range a {
		for j, _ := range a {
			if less(a[j], a[i]) {
				a[i], a[j] = a[j], a[i]
			}
		}
	}
}

This algorithm is naive, but it is easy to understand.

Then we can sort an array of integers using a variety of comparison functions:

func main() {
	a := []int{45, 9, 45, 0, 9, 1, 4, 3}
	sort(a, func(x, y int) bool { return x < y })
	fmt.Println(a)
	sort(a, func(x, y int) bool { return x > y })
	fmt.Println(a)
	sort(a, func(x, y int) bool { return x%10 < y%10 })
	fmt.Println(a)
}

The third example sorts the array by the last digit of the numbers.