Closures
Los closures son funciones que capturan variables de su ámbito envolvente. En Nyx, las funciones son valores de primera clase de tipo Fn — pueden retornarse desde funciones, almacenarse en variables y pasarse como argumentos.
Código
// Closures: función que retorna closure, tipo Fn, captura de entorno
fn make_counter(start: int) -> Fn {
var count: int = start
fn increment() -> int {
count = count + 1
return count
}
return increment
}
fn make_adder(n: int) -> Fn {
fn add(x: int) -> int {
return n + x
}
return add
}
fn apply(f: Fn, value: int) -> int {
return f(value)
}
fn main() -> int {
// Counter: cada llamada retorna el siguiente valor
let counter: Fn = make_counter(0)
print("counter: " + int_to_string(counter()))
print("counter: " + int_to_string(counter()))
print("counter: " + int_to_string(counter()))
// Dos contadores independientes
let c2: Fn = make_counter(10)
print("c2: " + int_to_string(c2()))
print("c2: " + int_to_string(c2()))
// Adder: closure que captura n del entorno
let add5: Fn = make_adder(5)
print("add5(3) = " + int_to_string(add5(3)))
print("add5(10) = " + int_to_string(add5(10)))
// Pasar closure como argumento
let add100: Fn = make_adder(100)
print("apply(add100, 7) = " + int_to_string(apply(add100, 7)))
return 0
}Salida
counter: 1 counter: 2 counter: 3 c2: 11 c2: 12 add5(3) = 8 add5(10) = 15 apply(add100, 7) = 107
Explicación
Un closure es una función anidada que hace referencia a variables de su función envolvente. En make_counter, la función interna increment captura la variable count declarada en el ámbito externo. Cada vez que se llama a increment, lee y modifica su propia copia de count — esto se llama un entorno compartido.
El tipo de retorno -> Fn indica que una función retorna otra función. El tipo Fn es el tipo de función genérico en Nyx; representa cualquier valor invocable, sin importar sus tipos específicos de parámetros y retorno.
Cada llamada a make_counter crea un closure independiente con su propio count privado. Los dos contadores counter y c2 no interfieren entre sí — comienzan en valores distintos y avanzan de forma independiente.
La función apply demuestra las funciones de orden superior: recibe un Fn y un int, y llama a la función con el valor. Este patrón es la base de los estilos de programación funcional — mapear, filtrar y componer comportamiento pasando funciones como datos.