Result: Ok y Err
Result es el tipo idiomático de Nyx para operaciones que pueden fallar con un mensaje de error. Una función retorna Result.Ok(value) cuando tiene éxito y Result.Err(message) cuando algo sale mal — lo cual hace que el manejo de errores sea explícito e imposible de ignorar por accidente.
Código
// Result: función que retorna Ok o Err, match exhaustivo para manejar ambos
enum Result {
Ok(int),
Err(String)
}
fn safe_divide(a: int, b: int) -> Result {
if b == 0 {
return Result.Err("division por cero")
}
return Result.Ok(a / b)
}
fn safe_sqrt(n: int) -> Result {
if n < 0 {
return Result.Err("raiz de negativo")
}
var i: int = 0
while i * i <= n {
i = i + 1
}
return Result.Ok(i - 1)
}
fn describe(r: Result) -> String {
return match r {
Result.Ok(v) => "ok: " + int_to_string(v),
Result.Err(e) => "error: " + e
}
}
fn main() -> int {
let r1: Result = safe_divide(100, 4)
print(describe(r1))
let r2: Result = safe_divide(10, 0)
print(describe(r2))
let r3: Result = safe_sqrt(16)
print(describe(r3))
let r4: Result = safe_sqrt(-5)
print(describe(r4))
return 0
}Salida
ok: 25 error: division por cero ok: 4 error: raiz de negativo
Explicación
Result es un enum común con dos variantes. En este ejemplo se define localmente con Ok(int) y Err(String), pero en programas Nyx reales normalmente usás el Result<T, E> genérico del prelude. De cualquier forma el patrón es idéntico: retornar una variante en caso de éxito, la otra en caso de fallo, y dejar que quien llama decida qué hacer.
safe_divide se protege contra la división por cero antes de realizar la operación. safe_sqrt usa un bucle entero manual para calcular raíces cuadradas por defecto (floor) sin aritmética de punto flotante, retornando un error para entradas negativas. Ambas funciones comunican el fallo a través del sistema de tipos en lugar de excepciones o códigos de error fuera de banda.
El helper describe hace match exhaustivo sobre ambas variantes. El compilador exige que se maneje cada variante — si más adelante agregás una tercera variante al enum, cada sitio de match existente se convierte en un error de compilación hasta que manejes el nuevo caso. Esta verificación de exhaustividad es una de las propiedades de seguridad más poderosas de los tipos algebraicos.