Home
Go (Fundamentals) 101
Go Generics 101
Go Details & Tips 101
Go Optimizations 101
Go Quizzes 101
Go Q&A 101
Go Practices 101
Go Bugs 101
Go 101 Blog
Go 101 Apps & Libs
Go Optimizations 101, Go Details & Tips 101 and Go Generics 101 are all updated for Go 1.24 now. The most cost-effective way to get them is through this book bundle in the Leanpub book store.

TapirMD - a powerful, next-generation markup language that simplifies content creation (much more powerful than markdown). You can experience it online here.

Generics

Before Go 1.18, Go only supported built-in generics. Since Go 1.18, Go also supports custom generics. This article only introduces built-in generics.

Go built-in generic types are supported through first-class citizen composite types. We can use composite types to create infinite custom types by using the composite types. This article will show some type composition examples and explain how to read these composited types.

Type Composition Examples

Type compositions in Go are designed very intuitive and easy to interpret. It is hardly to get lost in understanding Go composite types, even if for some very complex ones. The following will list several type composition examples, from simpler ones to more complex ones.

Let's view an simple composite type literal. 

[3][4]int

When interpreting a composite type, we should look at it from left to right. The [3] on the left in the above type literal indicates that this type is an array type. The whole right part following the [4]int is another array type, which is the element type of the first array type. The element type of the element type (an array type) of the first array type is built-in type int. The first array type can be viewed as a two-dimensional array type.

An example on using this two-dimensional array type. 
package main

import (
	"fmt"
)

func main() {
	matrix := [3][4]int{
		{1, 0, 0, 1},
		{0, 1, 0, 1},
		{0, 0, 1, 1},
	}

	matrix[1][1] = 3
	a := matrix[1] // type of a is [4]int
	fmt.Println(a) // [0 3 0 1]
}

Similarly,

Let's view another type. 

chan *[16]byte

The chan keyword at the left most indicates this type is a channel type. The whole right part *[16]byte, which is a pointer type, denotes the element type of this channel type. The base type of the pointer type is [16]byte, which is an array type. The element type of the array type is byte.

An example on using this channel type. 
package main

import (
	"fmt"
	"time"
	"crypto/rand"
)

func main() {
	c := make(chan *[16]byte)

	go func() {
		// Use two arrays to avoid data races.
		var dataA, dataB = new([16]byte), new([16]byte)
		for {
			_, err := rand.Read(dataA[:])
			if err != nil {
				close(c)
			} else {
				c <- dataA
				dataA, dataB = dataB, dataA
			}
		}
	}()

	for data := range c {
		fmt.Println((*data)[:])
		time.Sleep(time.Second / 2)
	}
}

Similarly, type map[string][]func(int) int is a map type. The key type of this map type is string. The remaining right part []func(int) int denotes the element type of the map type. The [] indicates the element type is a slice type, whose element type is a function type func(int) int.

An example on using the just explained map type. 

package main

import "fmt"

func main() {
	addone := func(x int) int {return x + 1}
	square := func(x int) int {return x * x}
	double := func(x int) int {return x + x}

	transforms := map[string][]func(int) int {
		"inc,inc,inc": {addone, addone, addone},
		"sqr,inc,dbl": {square, addone, double},
		"dbl,sqr,sqr": {double, double, square},
	}

	for _, n := range []int{2, 3, 5, 7} {
		fmt.Println(">>>", n)
		for name, transfers := range transforms {
			result := n
			for _, xfer := range transfers {
				result = xfer(result)
			}
			fmt.Printf(" %v: %v \n", name, result)
		}
	}
}

Below is a type which looks some complex. 

[]map[struct {
	a int
	b struct {
		x string
		y bool
	}
}]interface {
	Build([]byte, struct {x string; y bool}) error
	Update(dt float64)
	Destroy()
}

Let's read it from left to right. The starting [] at the left most indicates this type is a slice type. The following map keyword shows the element type of the slice type is a map type. The struct type denoted by the struct literal enclosed in the [] following the map keyword is the key type of the map type. The element type of the map type is an interface type which specifies three methods. The key type, a struct type, has two fields, one field a is of int type, and the other field b is of another struct type struct {x string; y bool}.

Please note that the second struct type is also used as one parameter type of one method specified by the just mentioned interface type.

To get a better readability, we often decompose such a type into multiple type declarations. The type alias T declared in the following code and the just explained type above denote the identical type. 

type B = struct {
	x string
	y bool
}

type K = struct {
	a int
	b B
}

type E = interface {
	Build([]byte, B) error
	Update(dt float64)
	Destroy()
}

type T = []map[K]E

Built-in Generic Functions

Besides the built-in generics for composite types, there are several built-in functions which also support generics. Such as the built-in len function can be used to get the length of values of arrays, slices, maps, strings and channels. Generally, the functions in the unsafe standard package are also viewed as built-in functions. The built-in generic functions have been introduced in previous articles,

Custom Generics

Since version 1.18, Go has already supported custom generics. Please read the Go Generics 101 book to get how to use custom generics.

(more articles ↡)

The Go 101 project is hosted on Github. Welcome to improve Go 101 articles by submitting corrections for all kinds of mistakes, such as typos, grammar errors, wording inaccuracies, description flaws, code bugs and broken links.

If you would like to learn some Go details and facts every serveral days, please follow Go 101's official Twitter account @zigo_101.

The digital versions of this book are available at the following places:
Tapir, the author of Go 101, has been on writing the Go 101 series books and maintaining the go101.org website since 2016 July. New contents will be continually added to the book and the website from time to time. Tapir is also an indie game developer. You can also support Go 101 by playing Tapir's games (made for both Android and iPhone/iPad):
Individual donations via PayPal are also welcome.
Articles in this book: