# Funciones anidadas y referencias a funciones Complementa [Funciones](/es/devkron/2.0/lenguaje/imperativo/funciones.md). Reglas confirmadas con Devkron 2.0.2. ## Ámbito de una función Una función solo ve **sus parámetros**, sus variables locales y las **variables globales** (las que empiezan con `@`). No ve las variables del programa principal ni las de la función que la llama: ```dkl @iva = 0.16 local = 100 con_iva::importe { return importe * (1 + @iva) } usa_local:: { return local * 2 } do print(con_iva(local)) x = usa_local() exception { do print(last_error()) do clear_exceptions() } ``` ```text 116.00 {1} Variable 'local' no definida en el contexto actual. [ejemplo.dkl][Ln= 15] ``` ## Funciones declaradas dentro de otras Se puede declarar una función dentro de otra. Su comportamiento: 1. **Se registra al ejecutarse la función padre**, en la tabla **global** de funciones. Antes de eso no existe (`Función no reconocida o no registrada`). 2. Una vez registrada, se puede llamar **desde cualquier parte** por su nombre, no solo desde la padre. 3. **No ve las variables locales de la padre.** No hay *closures*: igual que cualquier función, solo ve sus parámetros y las globales `@`. 4. Si dos funciones declaran una anidada con el mismo nombre, **gana la última que se ejecutó**. 5. Declararla dentro de un `if` o de un ciclo es válido; se vuelve a registrar en cada vuelta sin error. ```dkl padre::x { local_de_padre = 100 hijo::y { return y + 1 } espia:: { return local_de_padre } return hijo(x) } r = hijo(1) exception { do print("1) " + last_error()) do clear_exceptions() } do print("padre(5) = " + str(padre(5))) do print("2) hijo(10) = " + str(hijo(10))) r = espia() exception { do print("3) " + last_error()) do clear_exceptions() } ``` ```text 1) {1} Error en expresión: Función: hijo no reconocida o no registrada [ejemplo.dkl][Ln= 20] padre(5) = 6 2) hijo(10) = 11 3) {1} Variable 'local_de_padre' no definida en el contexto actual. [ejemplo.dkl][Ln= 16] ``` ### Evitar choques de nombres Como la tabla es global, dos funciones auxiliares con el mismo nombre en funciones distintas se pisan. Envuelva la anidada en un `codeblock` con espacio de nombres y llámela por su nombre completo: ```dkl a:: { codeblock ":a_int" { aux:: { return "aux de a" } } return a_int.aux() } b:: { codeblock ":b_int" { aux:: { return "aux de b" } } return b_int.aux() } do print(a() + " / " + b() + " / " + a_int.aux()) ``` ```text aux de a / aux de b / aux de a ``` Sin el `codeblock`, la tercera llamada devolvería la versión de `b` (la última que se registró). ### ¿Cuándo usarlas? Para funciones auxiliares que solo tienen sentido dentro de otra. Si necesita datos de la padre, páselos como parámetros. Para organizar una biblioteca, prefiera un `module "descripción:espacio"` en un archivo `.dkh` (ver [Organización del programa](/es/devkron/2.0/lenguaje/imperativo/organizacion.md)). ## Referencias a funciones `point variable to función` guarda una referencia a una función y `that variable(argumentos) -> resultado` la llama. La referencia es un `ref` como cualquier otro: - se pasa como parámetro (declarado con `&`); - se guarda en listas y en registros (campo con `*`); - se devuelve desde una función con `return variable` (no `return &variable`, que es error de sintaxis), aunque apunte a una función anidada. ```dkl doble::x { return x * 2 } cuadrado::x { return x * x } aplica_a_todos::&fn, &lista { ref res = list.create() for i=0; i r r -> res } return res } point f to doble point g to cuadrado do print(to.json(aplica_a_todos(g, list.of(1, 2, 3)))) // despacho por nombre con un registro new ops { @"doble*": f @"cuadrado*": g } nombre = "cuadrado" ref op = @@(ops, "&" + nombre) that op(9) -> r2 do print(nombre + "(9) = " + str(r2)) ``` ```text [1,4,9] cuadrado(9) = 81 ``` ### Devolver una referencia a una función anidada ```dkl fabrica:: { interna::x { return x + 1000 } point p to interna return p } ref q = fabrica() that q(1) -> r do print(r) ``` ```text 1001 ``` Recuerde que no hay *closures*: si la función devuelta necesita un dato de la fábrica, este tiene que vivir en una global `@` (compartida por todas las referencias) o pasarse como parámetro en cada llamada. ### Limitaciones - Los argumentos de `that f(…)` **no pueden contener llamadas a funciones**: `that f(abs(x)) -> r` falla al ejecutar con `Función: thatf no reconocida o no registrada`. Calcule antes el valor en una variable. - Los `alias` de función no valen en `point … to`: use el nombre completo.