Enums_

Variantes Simples / Unit Variants

PT-BR:
A forma mais simples de enum tem apenas variantes sem dados associados (variantes unitárias).

EN-US:
The simplest form of enum has only variants with no associated data (unit variants).

module enums

enum Cor {
    Vermelho,
    Verde,
    Azul
}

enum DiaSemana {
    Segunda,
    Terca,
    Quarta,
    Quinta,
    Sexta,
    Sabado,
    Domingo
}

public func main() {
    let cor = Cor::Vermelho
    let dia = DiaSemana::Sexta
}

Variantes com Dados Tuple / Tuple Variant Enums

PT-BR:
Variantes podem carregar dados anônimos (estilo tupla).

EN-US:
Variants can carry anonymous data (tuple-style).

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

enum Resultado<T, E> {
    Ok(T),
    Err(E)
}

enum Mensagem {
    Sair,
    Mover(int, int),          // x, y
    EscreverTexto(string),
    MudarCor(int, int, int)   // r, g, b
}

public func main() {
    let algum = Opcao::Algum(42)
    let nenhum: Opcao<int> = Opcao::Nenhum

    let ok = Resultado::Ok(100)
    let erro = Resultado::Err("algo deu errado")

    let msg = Mensagem::Mover(10, 20)
    let texto = Mensagem::EscreverTexto("Olá!")
}

Variantes com Campos Nomeados / Struct-Style Variants

PT-BR:
Variantes também podem ter campos nomeados, como um struct embutido.

EN-US:
Variants can also have named fields, like an embedded struct.

enum Forma {
    Circulo { raio: float },
    Retangulo { largura: float, altura: float },
    Triangulo { base: float, altura: float },
    Ponto                         // Variante unitária misturada / mixed unit variant
}

enum Cor {
    Rgb { r: int, g: int, b: int },
    Hsv { h: float, s: float, v: float },
    Nomeada(string)               // Variante tuple misturada / mixed tuple variant
}

public func main() {
    let circulo = Forma::Circulo { raio: 5.0 }
    let rect = Forma::Retangulo { largura: 4.0, altura: 6.0 }
    let vermelho = Cor::Rgb { r: 255, g: 0, b: 0 }
    let azul_ceu = Cor::Nomeada("azul céu")
}

Usando Enums com Match / Using Enums with Match

func calcular_area(forma: Forma) returns float {
    match forma {
        when Forma::Circulo { raio } then raio * raio * 3.14159,
        when Forma::Retangulo { largura, altura } then largura * altura,
        when Forma::Triangulo { base, altura } then base * altura * 0.5,
        when Forma::Ponto then 0.0
    }
}

func descrever_cor(cor: Cor) returns string {
    match cor {
        when Cor::Rgb { r, g, b } then f"RGB({r}, {g}, {b})",
        when Cor::Hsv { h, s, v } then f"HSV({h}, {s}, {v})",
        when Cor::Nomeada(nome) then nome
    }
}

Enums Genéricos / Generic Enums

// Tipos built-in / Built-in types
enum Option<T> {
    Some(T),
    None
}

enum Result<T, E> {
    Ok(T),
    Err(E)
}

// Usando / Using
let talvez: Option<int> = Option::Some(42)
let nada: Option<string> = Option::None
let sucesso: Result<int, string> = Result::Ok(200)
let falha: Result<int, string> = Result::Err("não encontrado")

---