Enums

Los enums de Nyx son tipos de datos algebraicos (ADTs): cada variante puede transportar datos distintos, y las expresiones match las desestructuran de forma exhaustiva. Esto hace imposible olvidar un caso en tiempo de compilación.

Código

// Enums: definición, variantes con datos, match exhaustivo

enum Shape {
    Circle(int),
    Square(int),
    Rectangle(int, int)
}

fn area(s: Shape) -> int {
    return match s {
        Shape.Circle(r)        => r * r * 3,
        Shape.Square(l)        => l * l,
        Shape.Rectangle(w, h)  => w * h
    }
}

fn describe(s: Shape) -> String {
    return match s {
        Shape.Circle(r)        => "circulo de radio " + int_to_string(r),
        Shape.Square(l)        => "cuadrado de lado " + int_to_string(l),
        Shape.Rectangle(w, h)  => "rectangulo " + int_to_string(w) + "x" + int_to_string(h)
    }
}

fn main() -> int {
    let c: Shape = Shape.Circle(5)
    let sq: Shape = Shape.Square(4)
    let rect: Shape = Shape.Rectangle(3, 7)

    print(describe(c) + " -> area aprox " + int_to_string(area(c)))
    print(describe(sq) + " -> area " + int_to_string(area(sq)))
    print(describe(rect) + " -> area " + int_to_string(area(rect)))

    return 0
}

Salida

circulo de radio 5 -> area aprox 75
cuadrado de lado 4 -> area 16
rectangulo 3x7 -> area 21

Explicación

Un enum se declara con la palabra clave enum seguida de un nombre y una lista de variantes. Cada variante puede transportar cero o más valores tipados entre paréntesis: Circle(int) transporta un entero (el radio), Rectangle(int, int) transporta dos (ancho y alto). Las variantes sin paréntesis serían simples etiquetas.

Los valores de enum se construyen con notación de punto: Shape.Circle(5). Nótese que Nyx usa Shape.Circle, no Shape::Circle — el punto es el separador de variantes en todo el lenguaje.

La expresión match desestructura un valor de enum y vincula los datos internos a nombres locales. Cada rama tiene la forma Patrón => expresión. El compilador exige exhaustividad: si falta alguna variante en un match, el programa no compilará.

La fórmula de área para el círculo usa aritmética de enteros (r * r * 3 como aproximación de π·r²), por lo que el resultado está etiquetado como "aprox". Los programas reales usarían float y la biblioteca estándar math para obtener resultados precisos.

Source: examples/by-example/09-enums.nx