Recursión
Nyx soporta funciones recursivas sin ninguna sintaxis especial. Una función simplemente se llama a sí misma por nombre. La clásica secuencia de Fibonacci es la demostración canónica: los casos base retornan de inmediato, y cualquier otra llamada reduce el problema hacia uno de esos casos base.
Código
// Recursión: fibonacci recursivo clásico
fn fib(n: int) -> int {
if n <= 1 {
return n
}
return fib(n - 1) + fib(n - 2)
}
fn main() -> int {
// Imprimir la secuencia de fibonacci del 0 al 10
print("Secuencia fibonacci (0..10):")
var i: int = 0
while i <= 10 {
let resultado: int = fib(i)
print("fib(" + int_to_string(i) + ") = " + int_to_string(resultado))
i = i + 1
}
// Calcular fib(20)
let f20: int = fib(20)
print("fib(20) = " + int_to_string(f20))
return 0
}Salida
Secuencia fibonacci (0..10): fib(0) = 0 fib(1) = 1 fib(2) = 1 fib(3) = 2 fib(4) = 3 fib(5) = 5 fib(6) = 8 fib(7) = 13 fib(8) = 21 fib(9) = 34 fib(10) = 55 fib(20) = 6765
Explicación
fib tiene dos casos base: n == 0 retorna 0 y n == 1 retorna 1. Ambos quedan cubiertos por la única guarda n <= 1. Para cualquier n mayor, la función se llama a sí misma dos veces y suma los resultados. Cada llamada recursiva avanza uno o dos pasos hacia el caso base, así que la recursión siempre termina.
La implementación ingenua con doble recursión tiene complejidad temporal exponencial — fib(n) recalcula subproblemas muchas veces. Para fib(20) esto sigue siendo instantáneo, pero para entradas grandes (digamos fib(40)) se prefiere una versión con memoización o iterativa. Los benchmarks de Nyx muestran que fib(40) se completa en ~166 ms con el enfoque ingenuo.
La recursión en Nyx compila directamente a llamadas de función nativas vía LLVM. No hay overhead de intérprete, y el código generado es equivalente al que se escribiría en C.