Generics em Golang: parâmetros de tipo, restrições e exemplos

Uma função genérica

Os parâmetros de tipo ficam entre colchetes, antes dos parâmetros comuns. Cada um tem uma restrição que diz quais tipos são permitidos.

package main

import (
	"fmt"
	"strconv"
)

func Map[T, U any](items []T, f func(T) U) []U {
	out := make([]U, 0, len(items))
	for _, it := range items {
		out = append(out, f(it))
	}
	return out
}

func main() {
	nums := []int{1, 2, 3}

	squares := Map(nums, func(n int) int { return n * n })
	fmt.Println(squares)

	labels := Map(nums, strconv.Itoa)
	fmt.Printf("%q\n", labels)

	lengths := Map([]string{"go", "rust", "c"}, func(s string) int { return len(s) })
	fmt.Println(lengths)
}

T e U são inferidos a partir dos argumentos, então você raramente escreve Map[int, string](...). A inferência funciona a partir dos argumentos da função; ela não consegue inferir um tipo que aparece só no resultado. Para func Zero[T any]() T, você precisa escrever Zero[int]().

Antes do Go 1.18, essa função precisava ser escrita uma vez para cada tipo, ou receber []interface{} e perder a segurança de tipos.

Restrições

Uma restrição (constraint) é uma interface. Ela limita os tipos que podem ser usados e, em troca, diz ao compilador quais operações são permitidas nos valores desse tipo.

package main

import (
	"cmp"
	"fmt"
)

func Index[T comparable](s []T, target T) int {
	for i, v := range s {
		if v == target { // needs comparable
			return i
		}
	}
	return -1
}

func Largest[T cmp.Ordered](s []T) T {
	m := s[0]
	for _, v := range s[1:] {
		if v > m { // needs cmp.Ordered
			m = v
		}
	}
	return m
}

func main() {
	fmt.Println(Index([]string{"a", "b", "c"}, "c"))
	fmt.Println(Largest([]float64{2.5, 9.1, 4.0}))
	fmt.Println(Largest([]string{"pear", "apple", "zucchini"}))
}

Com any no lugar de comparable, v == target não compila: invalid operation: v == target (incomparable types in type set). É a restrição que torna o operador válido.

Essas duas funções já existem: slices.Index e slices.Max. Os pacotes padrão slices, maps e cmp cobrem a maior parte das necessidades genéricas do dia a dia, então confira neles antes de escrever as suas.

Restrições personalizadas com uniões de tipos e ~

Uma restrição pode listar tipos com |. Os operadores permitidos são os que todos os tipos listados suportam.

package main

import "fmt"

type Number interface {
	~int | ~int64 | ~float64
}

func Sum[T Number](nums []T) T {
	var total T
	for _, n := range nums {
		total += n
	}
	return total
}

type Cents int64

func main() {
	fmt.Println(Sum([]int{1, 2, 3}))
	fmt.Println(Sum([]float64{0.5, 0.25}))
	fmt.Println(Sum([]Cents{199, 250})) // works because of ~int64
}

O til importa. ~int64 significa "qualquer tipo cujo tipo subjacente seja int64", então o tipo nomeado Cents é aceito. Escrito como int64 puro, Sum([]Cents{...}) falha com Cents does not satisfy Number (possibly missing ~ for int64 in Number).

Interfaces que contêm uniões de tipos só podem ser usadas como restrições, nunca como tipos comuns de variável. var n Number não compila.

O pacote golang.org/x/exp/constraints tem as restrições prontas Integer, Float e Signed. Ele fica fora da biblioteca padrão, então o runner daqui não consegue importá-lo; cmp.Ordered é a restrição padrão.

Tipos genéricos

Structs, slices, maps e outros tipos também podem ter parâmetros de tipo. Métodos em um tipo genérico usam os parâmetros do receiver.

package main

import (
	"errors"
	"fmt"
)

type Stack[T any] struct {
	items []T
}

func (s *Stack[T]) Push(v T) {
	s.items = append(s.items, v)
}

func (s *Stack[T]) Pop() (T, error) {
	var zero T
	if len(s.items) == 0 {
		return zero, errors.New("empty stack")
	}
	v := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return v, nil
}

func (s *Stack[T]) Len() int { return len(s.items) }

type Pair[K comparable, V any] struct {
	Key K
	Val V
}

func main() {
	var s Stack[string]
	s.Push("a")
	s.Push("b")
	v, _ := s.Pop()
	fmt.Println(v, s.Len())

	_, err := (&Stack[int]{}).Pop()
	fmt.Println(err)

	p := Pair[string, int]{Key: "age", Val: 31}
	fmt.Printf("%+v\n", p)
}

Dois detalhes desse exemplo aparecem o tempo todo:

• O valor zero de T. var zero T é como você devolve "nada" em código genérico. Não existe um T{} ou nil que funcione para todo tipo.
• Instanciação. Um tipo genérico precisa ser instanciado antes do uso: Stack[string], e não Stack. Dentro dos próprios métodos, o receiver se escreve Stack[T].

O Go 1.24 trouxe aliases de tipo genéricos: type Set[T comparable] = map[T]struct{} agora compila.

Limites que você vai encontrar

• Sem parâmetros de tipo em métodos. func (s *Stack[T]) Map[U any](...) não é permitido. Use uma função de nível superior.
• Sem especialização. Você não pode escrever uma implementação separada para T = string. Um type switch sobre any(v) dentro da função é o contorno, e normalmente um sinal de que generics são a ferramenta errada.
• Sem restrições de operador por nome. Não dá para dizer "qualquer tipo com um método +"; você lista os tipos em uma união.
• Acesso a campos por meio de uma restrição não funciona. Mesmo que todos os tipos de uma união tenham um campo ID, v.ID não é permitido. Use um método na restrição.

Quando não usar generics

Generics servem para tipos contêiner (pilhas, sets, caches, árvores) e para algoritmos sobre slices e maps que fazem a mesma coisa para qualquer tipo de elemento. Eles não servem para tudo.

• Um único tipo concreto. Se a função só é chamada com []User, uma versão genérica acrescenta custo de leitura e mais nada.
• Comportamento que varia por tipo. É para isso que existem interfaces. Uma função que recebe um io.Writer é mais simples que uma que recebe [T io.Writer], e funciona igual.
• Substituir parâmetros interface. func Print[T fmt.Stringer](v T) não é melhor que func Print(v fmt.Stringer).

A orientação do próprio time do Go: escreva o código para um tipo específico primeiro, e recorra a parâmetros de tipo quando perceber que está escrevendo o mesmo código pela segunda vez, mudando só os tipos.

Erros comuns

• Usar any onde é preciso comparable ou cmp.Ordered. O compilador rejeita == ou < em um parâmetro de tipo any.
• Esquecer o ~. Tipos definidos pelo usuário como type ID int falham em uma restrição int pura.
• Devolver nil para um parâmetro de tipo. Não é permitido, a menos que a restrição limite T a tipos parecidos com ponteiro. Devolva um valor zero.
• Escrever uma função genérica que já existe. Confira slices, maps e cmp antes.