Parâmetros de Tipo e Interfaces de Restrição

Parâmetros de tipo são declarados em listas de colchetes, e interfaces de restrição definem quais tipos podem substituí-los usando métodos, tipos subjacentes (~T) e uniões (|).

Resumo

Parâmetros de tipo transformam tipos concretos em variáveis de tempo de compilação para funções e tipos nomeados.

Interfaces de restrição são as barreiras de segurança: elas listam operações e conjuntos de tipos permitidos.

O operador ~ corresponde a tipos nomeados pelo tipo subjacente; | une múltiplos tipos ou tipos subjacentes em uma restrição.

Tipos de restrição nomeados mantêm as APIs legíveis quando o mesmo limite aparece em muitas assinaturas.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

// Restrição nomeada - reutilizável entre APIs
type Ordered interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
    ~float32 | ~float64 |
    ~string
}
 
func Clamp[T Ordered](v, lo, hi T) T {
    if v < lo {
        return lo
    }
    if v > hi {
        return hi
    }
    return v
}

Quando usar isso:

• Você precisa de um corpo de função para vários tipos concretos que compartilham operadores ou métodos.
• Um tipo nomeado deve participar porque seu tipo subjacente corresponde (~byte).
• Múltiplos tipos não relacionados devem ser aceitos via união (int | string é inválido para operações compartilhadas - projete com cuidado).

Exemplo de Trabalho

package main
 
import (
    "fmt"
    "strconv"
)
 
// Restrição de método
type Stringable interface {
    String() string
}
 
// Tipo subjacente + união
type Digit interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}
 
type UserID int
 
func (id UserID) String() string {
    return strconv.Itoa(int(id))
}
 
func FormatAll[T Stringable](items []T) string {
    out := ""
    for i, v := range items {
        if i > 0 {
            out += ", "
        }
        out += v.String()
    }
    return out
}
 
func Twice[T Digit](v T) T {
    return v * 2
}
 
func main() {
    ids := []UserID{1, 2, 3}
    fmt.Println(FormatAll(ids))
    fmt.Println(Twice(UserID(5)))
}

O que isso demonstra:

• Restrições de método permitem chamadas como v.String() dentro do corpo genérico.
• ~int permite que UserID satisfaça Digit sem listar todos os tipos de int nomeados.
• Restrições separadas compõem diferentes capacidades (Stringable vs Digit).

Mergulho Profundo

Como Funciona

• Parâmetros de tipo são declarados em funções (func F[T any]()) ou tipos (type Stack[T any] struct{}).
• Cada parâmetro tem uma interface de restrição; o uso padrão sem restrição é any.
• O compilador calcula o conjunto de tipos da restrição; apenas tipos nesse conjunto podem instanciar o genérico.
• O corpo da função só pode usar operações válidas para todos os tipos no conjunto (as regras do conjunto de tipos principal).

Formas de Restrição em Resumo

Listas de Parâmetros de Tipo

Notas de Go

// Extrai restrições para nomes de nível de pacote para APIs públicas
type JSONMarshaler interface {
    MarshalJSON() ([]byte, error)
}
 
func Encode[T JSONMarshaler](v T) ([]byte, error) {
    return v.MarshalJSON()
}
 
// Embutindo restrições pré-declaradas
type Key interface {
    comparable
    fmt.Stringer
}

• Interfaces de restrição não podem embutir tipos não-interface arbitrários, exceto termos de tipo em uniões.
• Uma união não pode misturar operações incompatíveis - se um braço não tem <, o corpo não pode usar < em T.
• Use cmp.Ordered e cmp.Or da biblioteca padrão em vez de copiar grandes listas de união.

Armadilhas

• Usar int em vez de ~int - Tipos nomeados como type Celsius float64 não corresponderão apenas a float64. Correção: use ~float64 quando tipos nomeados devem se qualificar.
• União muito ampla para um corpo - int | string não pode usar + ou comparações compartilhadas além de == se não forem comparáveis juntas. Correção: restrinja a união ou divida as funções.
• Embutir comparable incorretamente - interface { comparable; []byte } é inválido porque slices não são comparáveis. Correção: liste apenas termos de tipo comparáveis.
• Interface de restrição apenas com métodos, sem conjunto de tipos - Conjuntos de métodos de interface vazia se comportam de forma diferente das uniões; leia a especificação para conjuntos de tipos principais comparable. Correção: teste instanciações em testes de tabela em tempo de compilação.
• Exportar uniões de restrição enormes - APIs públicas se tornam difíceis de ler e estabilizar. Correção: desexporte a restrição, exporte a função com limites mínimos.
• Parâmetros de tipo duplicados - [T any, T comparable] é inválido. Correção: um nome por parâmetro na lista.

Alternativas

FAQs

Relacionados

• Generics in Go: Constraints Without Templates - visão geral conceitual
• Generics Basics - primeiros trechos genéricos
• Type Sets & the comparable Constraint - mergulho profundo em comparable
• Generic Algorithms: slices, maps & cmp Packages - uso de cmp.Ordered
• When to Avoid Generics in Go APIs - orientação de API pública

Versões de 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 - verifique na compilação), gin (última - verifique na compilação), echo (última - verifique na compilação), google.golang.org/grpc (última - verifique na compilação), sigs.k8s.io/controller-runtime (última - verifique na compilação), kubebuilder (última - verifique na compilação), tinygo (última - verifique os alvos de placa na compilação), wazero (última - verifique na compilação), e golangci-lint (última - verifique o conjunto de linters na compilação).

49454e4f4d5f434e4f5904434556494d43451f1a1d56181a181c1a1d