Generics no Zero: parâmetros de tipo em funções e shapes

Por que generics

Logo você esbarra em tipos que deveriam funcionar para mais de um tipo de elemento. Um "par" de dois valores não se importa se os valores são inteiros, strings ou algum shape definido pelo usuário. Generics permitem que você escreva o tipo uma vez e o instancie com quaisquer tipos de elemento que o chamador precisar.

A alternativa — escrever IntPair, StringPair, BytePair e assim por diante — fica chata rápido e não compõe. Generics em Zero são a ferramenta padrão para o trabalho.

Funções genéricas

Declare parâmetros de tipo entre sinais de menor/maior entre o nome da função e a lista de parâmetros:

fun makePair<T, U>(left: T, right: U) -> Pair<T, U> {
    return Pair { left: left, right: right }
}

T e U são tipos placeholder — quem chama decide o que são.

Chamadas em geral não precisam soletrá-los; o compilador infere a partir dos tipos dos argumentos:

let pair = makePair(40, 2_u8)

Aqui T é inferido como i32 (o padrão para um literal inteiro sem sufixo) e U é u8 (vindo do sufixo _u8). A ligação resultante pair tem tipo Pair<i32, u8>.

Se a inferência escolheria os tipos errados — porque os literais são ambíguos, por exemplo — você pode fixar os parâmetros no ponto de chamada:

let pair = makePair<u8, u8>(1, 2)

(Se a sintaxe de chamada com sinais de menor/maior é exatamente essa pode variar entre versões do Zero; confira a documentação atual para a grafia precisa. O comportamento "inferência primeiro" é a parte estável.)

Shapes genéricos

Shapes recebem parâmetros de tipo do mesmo jeito:

shape Pair<T, U> {
    left: T,
    right: U,
}

O tipo de cada campo pode mencionar os parâmetros. Instâncias fixam os parâmetros:

let intBytes: Pair<i32, u8> = Pair { left: 40, right: 2_u8 }
let words:    Pair<String, String> = Pair { left: "hi", right: "there" }

Um exemplo combinando um shape genérico e uma função genérica — clique em Run para ver a inferência trabalhando:

shape Pair<T, U> {
    left: T,
    right: U,
}

fun makePair<T, U>(left: T, right: U) -> Pair<T, U> {
    return Pair { left: left, right: right }
}

pub fun main(world: World) -> Void raises {
    let pair: Pair<i32, u8> = makePair(40, 2_u8)
    if pair.left == 40 && pair.right == 2_u8 {
        check world.out.write("generic pair ok\n")
    } else {
        check world.out.write("generic pair broke\n")
    }
}

Uma declaração de shape genérico, uma função genérica, um ponto de chamada com tipos fortes. Sem boilerplate de IntBytePair.

Type aliases

Quando o mesmo tipo parametrizado aparece muitas vezes, dê um nome com type:

type BytePair = Pair<u8, u8>

Agora BytePair é intercambiável com Pair<u8, u8> em qualquer lugar onde você possa escrever um tipo:

type BytePair = Pair<u8, u8>

shape Pair<T, U> {
    left: T,
    right: U,
}

pub fun main(world: World) -> Void raises {
    let pair: BytePair = Pair { left: 1_u8, right: 2_u8 }
    if pair.left == 1_u8 && pair.right == 2_u8 {
        check world.out.write("type alias ok\n")
    } else {
        check world.out.write("type alias broke\n")
    }
}

Um alias é só uma funcionalidade de nomenclatura — não cria um tipo distinto. Uma função que recebe um BytePair aceita tranquilamente um valor de tipo Pair<u8, u8> (e vice-versa).

Generics na biblioteca padrão

O mesmo mecanismo é a base de boa parte da biblioteca padrão. Alguns que você vai ver em código Zero real:

• Maybe<T> — um valor opcional, carregando um T ou nada.
• Span<T> — uma fatia emprestada sobre valores T. Span<u8> é a visão canônica sobre um buffer de bytes.
• ref<T> e mutref<T> — tipos de referência explícitos para quando você precisa compartilhar dado sem copiar.

Você não precisa aprender todos de uma vez. O ponto dos generics é que o mesmo shape funciona para qualquer tipo de elemento que você tenha à mão.

Quando generics compensam (e quando não)

Recorra a generics quando se ver escrevendo a mesma função ou shape duas vezes com tipos de elemento diferentes. Recorra a um tipo concreto quando:

• A lógica da função só faz sentido para um tipo específico (um parser para Strings, digamos).
• Você quer que o tipo apareça em mensagens de erro para facilitar a depuração.
• As características de desempenho dependem de um tamanho específico em memória.

O custo dos generics é real — binários maiores (cada instanciação gera código novo) e tempos de compilação um pouco mais lentos. Para a maior parte do código de aplicação, esse custo é desprezível, mas vale saber quando você está construindo código compacto, estilo embarcado, em que o tamanho do binário importa.

Uma nota sobre constraints

Alguns sistemas de generics permitem restringir um parâmetro de tipo ("T precisa suportar ==", "T precisa implementar Iterator"). A história de constraints do Zero pré-1.0 ainda está evoluindo — os exemplos no repo oficial usam generics na forma simples, sem bounds elaborados. Conforme a linguagem assenta, espere que sintaxe de constraint chegue numa forma pequena e regular, consistente com o resto da linguagem. Por enquanto, escreva generics que funcionam para qualquer T que você de fato passa, e deixe o compilador te dizer quando uma operação não é suportada.

A seguir: enums

Generics permitem parametrizar sobre tipos. O próximo bloco de construção fica no outro extremo do espectro — enums, o tipo enumeração simples do Zero para casos em que as variantes não carregam dado extra.