Noções Básicas de Genéricos

10 exemplos para você começar com Genéricos - 7 básicos e 3 intermediários.

Pré-requisitos

Instale o Go 1.26.x ou posterior em go.dev/dl.
Genéricos requerem Go 1.18+; exemplos da biblioteca padrão slices/maps/cmp precisam do Go 1.21+.
Crie um módulo: mkdir gdemo && cd gdemo && go mod init example.com/gdemo.
Salve os trechos como main.go e execute com go run ..

Exemplos Básicos

1. Sua primeira função genérica

Um parâmetro de tipo T com a restrição cmp.Ordered habilita < em números e strings.

package main
 
import (
    "cmp"
    "fmt"
)
 
func Max[T cmp.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}
 
func main() {
    fmt.Println(Max(3, 7), Max("a", "z"))
}

Parâmetros de tipo aparecem em colchetes antes da lista de parâmetros.
cmp.Ordered é uma restrição da biblioteca padrão para tipos ordenados.
O compilador infere T a partir dos argumentos no local da chamada.

Relacionado: Genéricos em Go: Restrições Sem Templates - modelo mental para restrições

2. Argumentos de tipo explícitos

Passe argumentos de tipo quando a inferência for ambígua.

package main
 
import "fmt"
 
func Zero[T any]() T {
    var z T
    return z
}
 
func main() {
    fmt.Printf("%v %q\n", Zero[int](), Zero[string]())
}

any é a restrição que aceita todos os tipos.
Zero[int]() substitui T por int.
O valor zero de T é retornado sem reflexão.

Relacionado: Parâmetros de Tipo e Interfaces de Restrição - any e restrições nomeadas

3. slice.Contains genérico

Itere com range sem índice sobre []T.

package main
 
import "fmt"
 
func Contains[T comparable](s []T, v T) bool {
    for _, x := range s {
        if x == v {
            return true
        }
    }
    return false
}
 
func main() {
    fmt.Println(Contains([]string{"a", "b"}, "b"))
}

comparable permite == e != em T.
Slices de elementos comparáveis são aceitáveis; T em si não pode ser um tipo slice em uma função de chave de mapa comparable.
Prefira slices.Contains da biblioteca padrão em código de produção.

Relacionado: Conjuntos de Tipos e a Restrição comparable - o que comparable permite

4. Struct genérico: stack

Parâmetros de tipo em tipos struct são carregados através dos métodos.

package main
 
import "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, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    v := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return v, true
}
 
func main() {
    var st Stack[int]
    st.Push(1)
    v, _ := st.Pop()
    fmt.Println(v)
}

Métodos em Stack[T] usam o mesmo T da struct.
Cada instanciação (Stack[int], Stack[string]) é um tipo distinto.
O valor zero Stack[int]{} está pronto para uso.

Relacionado: Estruturas de Dados Genéricas: Conjuntos, Filas, Mapas - contêineres reutilizáveis

5. Restrição de interface com um método

Restrições podem exigir métodos, não apenas uniões de tipos.

package main
 
import "fmt"
 
type Stringer interface {
    String() string
}
 
func Join[T Stringer](items []T, sep string) string {
    if len(items) == 0 {
        return ""
    }
    out := items[0].String()
    for _, it := range items[1:] {
        out += sep + it.String()
    }
    return out
}
 
type ID int
 
func (id ID) String() string { return fmt.Sprintf("id:%d", int(id)) }
 
func main() {
    fmt.Println(Join([]ID{1, 2}, ","))
}

T Stringer significa que cada T deve implementar String() string.
A satisfação da interface é implícita - sem palavra-chave implements.
Chamadas de método em T são permitidas porque estão na restrição.

Relacionado: Parâmetros de Tipo e Interfaces de Restrição - restrições de método

6. Chaves de mapa com `comparable`

Construa uma tabela de frequência com chave T.

package main
 
import "fmt"
 
func Count[T comparable](items []T) map[T]int {
    m := make(map[T]int)
    for _, v := range items {
        m[v]++
    }
    return m
}
 
func main() {
    fmt.Println(Count([]string{"a", "b", "a"}))
}

Chaves de mapa devem ser comparable.
Chaves de struct funcionam quando todos os campos são comparáveis.
Slices e mapas não podem ser chaves de mapa.

Relacionado: Conjuntos de Tipos e a Restrição comparable - regras para chaves de mapa

7. Instancie um padrão de alias de tipo genérico

A declaração de variável curta escolhe a instanciação.

package main
 
import "fmt"
 
type Pair[A, B any] struct {
    First  A
    Second B
}
 
func main() {
    p := Pair[string, int]{"go", 1}
    fmt.Println(p.First, p.Second)
}

Múltiplos parâmetros de tipo são separados por vírgula: [A, B any].
Tipos de campo usam os parâmetros diretamente.
A inferência em construtores é limitada; argumentos de tipo explícitos são comuns em tipos.

Relacionado: Estruturas de Dados Genéricas: Conjuntos, Filas, Mapas - contêineres com múltiplos parâmetros

Exemplos Intermediários

8. Restrição de tipo subjacente com `~`

Aceite tipos nomeados com base em seu tipo subjacente.

package main
 
import "fmt"
 
type Celsius float64
type Fahrenheit float64
 
type Number interface {
    ~float64
}
 
func Double[T Number](v T) T {
    return v * 2
}
 
func main() {
    fmt.Println(Double(Celsius(10)), Double(Fahrenheit(20)))
}

~float64 inclui Celsius e Fahrenheit porque seu tipo subjacente é float64.
Sem ~, apenas o tipo literal float64 corresponderia.
Use tipos de restrição nomeados para reutilização entre funções.

Relacionado: Parâmetros de Tipo e Interfaces de Restrição - profundidade do operador ~

9. Restrição de união para mínimo numérico

Tipos de união listam os tipos concretos permitidos.

package main
 
import "fmt"
 
type Integer interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}
 
func Abs[T Integer](v T) T {
    if v < 0 {
        return -v
    }
    return v
}
 
func main() {
    fmt.Println(Abs(int8(-3)), Abs(int64(-9)))
}

| constrói uma união dentro de uma restrição de interface.
Operações no corpo devem ser válidas para todos os membros da união.
Amplie uniões com cuidado - a legibilidade cai rapidamente.

Relacionado: Parâmetros de Tipo e Interfaces de Restrição - limites de união

10. slices.Contains da biblioteca padrão

Procure por helpers genéricos na biblioteca padrão antes de cópias personalizadas.

package main
 
import (
    "fmt"
    "slices"
)
 
func main() {
    nums := []int{1, 2, 3}
    fmt.Println(slices.Contains(nums, 2))
    fmt.Println(slices.Index(nums, 9))
}

Os pacotes slices e maps são APIs genéricas por padrão no Go 1.21+.
Eles são mantidos com o runtime e a análise de escape em mente.
Genéricos personalizados ainda ajudam para contêineres e algoritmos específicos do domínio.

Relacionado: Algoritmos Genéricos: Pacotes slices, maps & cmp - catálogo da biblioteca padrão

Versões do Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).

Pré-requisitos

Instale o Go 1.26.x ou posterior em go.dev/dl.
Genéricos requerem Go 1.18+; exemplos da biblioteca padrão slices/maps/cmp precisam do Go 1.21+.
Crie um módulo: mkdir gdemo && cd gdemo && go mod init example.com/gdemo.
Salve os trechos como main.go e execute com go run ..

Exemplos Básicos

1. Sua primeira função genérica

Um parâmetro de tipo T com a restrição cmp.Ordered habilita < em números e strings.

package main
 
import (
    "cmp"
    "fmt"
)
 
func Max[T cmp.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}
 
func main() {
    fmt.Println(Max(3, 7), Max("a", "z"))
}

Parâmetros de tipo aparecem em colchetes antes da lista de parâmetros.
cmp.Ordered é uma restrição da biblioteca padrão para tipos ordenados.
O compilador infere T a partir dos argumentos no local da chamada.

Relacionado: Genéricos em Go: Restrições Sem Templates - modelo mental para restrições

2. Argumentos de tipo explícitos

Passe argumentos de tipo quando a inferência for ambígua.

package main
 
import "fmt"
 
func Zero[T any]() T {
    var z T
    return z
}
 
func main() {
    fmt.Printf("%v %q\n", Zero[int](), Zero[string]())
}

any é a restrição que aceita todos os tipos.
Zero[int]() substitui T por int.
O valor zero de T é retornado sem reflexão.

Relacionado: Parâmetros de Tipo e Interfaces de Restrição - any e restrições nomeadas

3. slice.Contains genérico

Itere com range sem índice sobre []T.

package main
 
import "fmt"
 
func Contains[T comparable](s []T, v T) bool {
    for _, x := range s {
        if x == v {
            return true
        }
    }
    return false
}
 
func main() {
    fmt.Println(Contains([]string{"a", "b"}, "b"))
}

comparable permite == e != em T.
Slices de elementos comparáveis são aceitáveis; T em si não pode ser um tipo slice em uma função de chave de mapa comparable.
Prefira slices.Contains da biblioteca padrão em código de produção.

Relacionado: Conjuntos de Tipos e a Restrição comparable - o que comparable permite

4. Struct genérico: stack

Parâmetros de tipo em tipos struct são carregados através dos métodos.

package main
 
import "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, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    v := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return v, true
}
 
func main() {
    var st Stack[int]
    st.Push(1)
    v, _ := st.Pop()
    fmt.Println(v)
}

Métodos em Stack[T] usam o mesmo T da struct.
Cada instanciação (Stack[int], Stack[string]) é um tipo distinto.
O valor zero Stack[int]{} está pronto para uso.

Relacionado: Estruturas de Dados Genéricas: Conjuntos, Filas, Mapas - contêineres reutilizáveis

5. Restrição de interface com um método

Restrições podem exigir métodos, não apenas uniões de tipos.

package main
 
import "fmt"
 
type Stringer interface {
    String() string
}
 
func Join[T Stringer](items []T, sep string) string {
    if len(items) == 0 {
        return ""
    }
    out := items[0].String()
    for _, it := range items[1:] {
        out += sep + it.String()
    }
    return out
}
 
type ID int
 
func (id ID) String() string { return fmt.Sprintf("id:%d", int(id)) }
 
func main() {
    fmt.Println(Join([]ID{1, 2}, ","))
}

T Stringer significa que cada T deve implementar String() string.
A satisfação da interface é implícita - sem palavra-chave implements.
Chamadas de método em T são permitidas porque estão na restrição.

Relacionado: Parâmetros de Tipo e Interfaces de Restrição - restrições de método

6. Chaves de mapa com `comparable`

Construa uma tabela de frequência com chave T.

package main
 
import "fmt"
 
func Count[T comparable](items []T) map[T]int {
    m := make(map[T]int)
    for _, v := range items {
        m[v]++
    }
    return m
}
 
func main() {
    fmt.Println(Count([]string{"a", "b", "a"}))
}

Chaves de mapa devem ser comparable.
Chaves de struct funcionam quando todos os campos são comparáveis.
Slices e mapas não podem ser chaves de mapa.

Relacionado: Conjuntos de Tipos e a Restrição comparable - regras para chaves de mapa

7. Instancie um padrão de alias de tipo genérico

A declaração de variável curta escolhe a instanciação.

package main
 
import "fmt"
 
type Pair[A, B any] struct {
    First  A
    Second B
}
 
func main() {
    p := Pair[string, int]{"go", 1}
    fmt.Println(p.First, p.Second)
}

Múltiplos parâmetros de tipo são separados por vírgula: [A, B any].
Tipos de campo usam os parâmetros diretamente.
A inferência em construtores é limitada; argumentos de tipo explícitos são comuns em tipos.

Relacionado: Estruturas de Dados Genéricas: Conjuntos, Filas, Mapas - contêineres com múltiplos parâmetros

Exemplos Intermediários

8. Restrição de tipo subjacente com `~`

Aceite tipos nomeados com base em seu tipo subjacente.

package main
 
import "fmt"
 
type Celsius float64
type Fahrenheit float64
 
type Number interface {
    ~float64
}
 
func Double[T Number](v T) T {
    return v * 2
}
 
func main() {
    fmt.Println(Double(Celsius(10)), Double(Fahrenheit(20)))
}

~float64 inclui Celsius e Fahrenheit porque seu tipo subjacente é float64.
Sem ~, apenas o tipo literal float64 corresponderia.
Use tipos de restrição nomeados para reutilização entre funções.

Relacionado: Parâmetros de Tipo e Interfaces de Restrição - profundidade do operador ~

9. Restrição de união para mínimo numérico

Tipos de união listam os tipos concretos permitidos.

package main
 
import "fmt"
 
type Integer interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}
 
func Abs[T Integer](v T) T {
    if v < 0 {
        return -v
    }
    return v
}
 
func main() {
    fmt.Println(Abs(int8(-3)), Abs(int64(-9)))
}

| constrói uma união dentro de uma restrição de interface.
Operações no corpo devem ser válidas para todos os membros da união.
Amplie uniões com cuidado - a legibilidade cai rapidamente.

Relacionado: Parâmetros de Tipo e Interfaces de Restrição - limites de união

10. slices.Contains da biblioteca padrão

Procure por helpers genéricos na biblioteca padrão antes de cópias personalizadas.

package main
 
import (
    "fmt"
    "slices"
)
 
func main() {
    nums := []int{1, 2, 3}
    fmt.Println(slices.Contains(nums, 2))
    fmt.Println(slices.Index(nums, 9))
}

Os pacotes slices e maps são APIs genéricas por padrão no Go 1.21+.
Eles são mantidos com o runtime e a análise de escape em mente.
Genéricos personalizados ainda ajudam para contêineres e algoritmos específicos do domínio.

Relacionado: Algoritmos Genéricos: Pacotes slices, maps & cmp - catálogo da biblioteca padrão

Versões do Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).

Noções Básicas de Genéricos

Buscar na documentação

Noções Básicas de Genéricos