Genéricos_

PT-BR:
Genéricos permitem escrever código que funciona com múltiplos tipos sem duplicação. SpectraLang suporta parâmetros de tipo em funções, structs, enums e traits.

EN-US:
Generics allow writing code that works with multiple types without duplication. SpectraLang supports type parameters in functions, structs, enums, and traits.

Funções Genéricas / Generic Functions

// Parâmetro de tipo simples / Simple type parameter
func primeiro<T>(arr: [T], n: int) returns T {
    return arr[0]
}

// Múltiplos parâmetros / Multiple parameters
func trocar<T>(a: T, b: T) returns (T, T) {
    return (b, a)
}

public func main() {
    let arr_int = [1, 2, 3]
    let arr_str = ["a", "b", "c"]

    let p1 = primeiro(arr_int, 3)
   // 1
    let p2 = primeiro(arr_str, 3)
   // "a"

    let (x, y) = trocar(10, 20)
     // x=20, y=10
}

Structs Genéricas / Generic Structs

record Pilha<T> {
    dados: [T],
    tamanho: int
}

impl Pilha<T> {
    func nova() returns Pilha<T> {
        Pilha { dados: [], tamanho: 0 }
    }

    func topo(&self) returns T {
        self.dados[self.tamanho - 1]
    }
}

Enums Genéricos / Generic Enums

// Option e Result são built-in mas poderiam ser definidos assim:
// Option and Result are built-in but could be defined like this:

enum Opcao<T> {
    Algum(T),
    Nenhum
}

enum Resultado<V, E> {
    Exito(V),
    Falha(E)
}

Trait Bounds / Trait Bounds

trait Comparavel {
    func comparar(&self, outro: &Self) returns int
  // -1, 0, ou 1
}

// Função que requer T implementar Comparavel / Function requiring T to implement Comparavel
func ordenar<T: Comparavel>(arr: [T], n: int) {
    // ... lógica de ordenação / sorting logic
}

// Múltiplos bounds com + / Multiple bounds with +
func exibir_e_comparar<T: Exibivel + Comparavel>(a: T, b: T) {
    println(a.exibir())
    let resultado = a.comparar(b)
}

---