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.
// 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 }
counter: 1 counter: 2 counter: 3 c2: 11 c2: 12 add5(3) = 8 add5(10) = 15 apply(add100, 7) = 107
Cómo funciona
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.