# Funciones abiertas y bloques `go` Una **función abierta** ejecuta, en un punto de su código, un bloque que le escribe quien la llama. Es el mecanismo de los iteradores `foreach.*` de `functions.dkh` y sirve para escribir los propios: recorrer una estructura, reintentar una operación, envolver una transacción, filtrar. Esta página describe su comportamiento completo, confirmado con Devkron 2.0.2. Varias reglas no son intuitivas (`return`, `break` y la asignación a variables expuestas); están aquí para que no sorprendan. ## Las tres piezas | Pieza | Dónde | Qué hace | |---|---|---| | `expose v1, v2` | en la función | publica variables de la función para que el bloque las lea | | `that` | en la función | punto donde se ejecuta el bloque de quien llama (`that` sin nada más) | | `go f (v1:a1, v2:a2) with(argumentos) -> r { … }` | en quien llama | llama a `f`, da un alias a cada variable expuesta y escribe el bloque | ```dkl // Recorre de inicio a fin con el paso indicado y expone cada valor rango::inicio, fin, paso { expose n, vuelta vuelta = 0 for n=inicio; n<=fin; n+paso { that vuelta = vuelta + 1 } return vuelta } suma = 0 texto = "" go rango (n:x, vuelta:k) with(10, 20, 5) -> total { suma = suma + x texto = texto + "[" + str(k) + ":" + str(x) + "]" } do print(texto) do print("suma=" + str(suma) + " vueltas=" + str(total)) ``` ```text [0:10][1:15][2:20] suma=45 vueltas=3 ``` Formas del `go` (todas las partes entre corchetes son opcionales): ```text go función [(expuesta:alias, …)] [with(argumentos)] [-> variable | ->* referencia] { bloque } ``` - `-> r` recibe el valor devuelto (número o cadena); `->* r` lo recibe como referencia (registro o lista). - En `go` se escribe el nombre completo de la función: los `alias` de función no valen aquí. - `that` sin argumentos fuera de una función es un error. ## Dónde corre el bloque **El bloque corre en el ámbito de quien llama**, no en el de la función. Por eso: - lee y **modifica** las variables de quien llama (en el ejemplo, `suma` y `texto`); - no ve las variables locales de la función, salvo las que esta expone, y solo a través de su alias. Esto es lo que permite escribir filter, map y reduce acumulando en variables propias (ver [Recetas de colecciones](/es/devkron/2.0/lenguaje/imperativo/recetas-de-colecciones.md)). ## Variables expuestas: solo lectura El alias se lee con el valor que tiene la variable de la función en el momento del `that`. **Asignarle un valor no cambia la variable de la función y no produce error.** Lo que ocurre en realidad es que se crea (o cambia) una variable **de quien llama** con ese nombre; dentro del bloque, el alias sigue leyéndose con el valor expuesto: ```dkl cuenta::max { expose i for i=0; i r { v = 99 lecturas = lecturas + str(v) + " " } do print(r) do print("dentro del bloque v se leyó como: " + trim(lecturas)) do print("quien llama ahora tiene su propia v = " + str(v)) ``` ```text fin con i=3 dentro del bloque v se leyó como: 0 1 2 quien llama ahora tiene su propia v = 99 ``` ### El alias y las flechas El alias no se puede usar directamente con las flechas de listas (`->`): el motor responde `La variable mapeada no está disponible`. Cópielo antes a una variable local: ```dkl ref numeros = list.of(1, 2, 3) go foreach.lnum(value:v) with(numeros) { x = v // copia local x * 2 -> dobles // correcto // v -> dobles // error: La variable mapeada no está disponible } do print(to.json(dobles)) ``` ```text [2,4,6] ``` Si quien llama ya tiene una variable con el mismo nombre que el alias (por ejemplo, porque un `go` anterior le asignó un valor), la flecha usa **esa** variable y no el valor expuesto. Copiar a una variable local evita los dos problemas. ## Responderle a la función: referencias expuestas La variable expuesta es de solo lectura, pero si contiene una **referencia** a un registro, el bloque sí puede modificar ese registro. Así la función recibe una respuesta del bloque: ```dkl filtrar::&lista { expose valor, resp new resp {} ref res = list.create() for i=0; i: 0 that if @@(resp, "#ok") { do list.addnum(res, valor) } } return res } ref nums = list.of(3, 8, 1, 12, 5) umbral = 4 go filtrar (valor:v, resp:r) with(nums) ->* grandes { r<"ok">: v > umbral } do print(to.json(grandes)) ``` ```text [8,12,5] ``` Alternativa equivalente: pasar un registro de contexto como argumento en `with(…)` y escribir en él desde el bloque. ## `return` dentro del bloque **`return` dentro del bloque sale de la función que contiene el `go`** (la de quien llama), con ese valor. No termina solo el bloque ni solo la función abierta. Así se escriben búsquedas con salida anticipada: ```dkl primer_multiplo::&lista, m { go foreach.lnum(value:v) with(lista) { x = v if mod(x, m) == 0 { return x } } return -1 } ref nums = list.of(7, 11, 12, 15, 18) do print(primer_multiplo(nums, 3)) do print(primer_multiplo(nums, 100)) ``` ```text 12 -1 ``` **En el nivel principal** (fuera de toda función), `return` dentro del bloque **termina el programa**, sin error y sin aviso, igual que un `return` escrito directamente ahí. Por eso las recetas con salida anticipada se escriben dentro de una función. ## `break` dentro del bloque **`break` dentro del bloque rompe el ciclo de quien llama**, es decir, el `for`, `while` o `repeat` que rodea al `go`, no el ciclo interno de la función abierta: ```dkl pruebas:: { salida = "" ref tres = list.of(1, 2, 3) for k=0; k<3 { go foreach.lnum(value:v) with(tres) { salida = salida + str(k) + ":" + str(v) + " " if k == 1 && v == 2 { break } } } return salida + "| k al salir = " + str(k) } do print(pruebas()) ``` ```text 0:1 0:2 0:3 1:1 1:2 | k al salir = 1 ``` Si no hay un ciclo alrededor del `go`, `break` sale de la función que contiene el `go`, que devuelve 0 (lo que sigue al `go` no se ejecuta). En el nivel principal, termina el programa. ## Errores dentro del bloque Un error en el bloque se atiende con el bloque `exception` de quien llama, colocado después del `go`: ```dkl ref l = list.of(1, 2) go foreach.lnum(value:v) with(l) { v -> directos } exception { do print("capturado: " + last_error()) do clear_exceptions() } ``` ```text capturado: {1} La variable mapeada no está disponible [ejemplo.dkl][Ln= 10] ``` ## Limitaciones de sintaxis - Los argumentos de `with( )` **no pueden contener llamadas a funciones**: `with(list.of(1, 2))` es error de sintaxis (109) al cargar el archivo. Ponga el valor en una variable antes. - Lo mismo vale para los argumentos de `that f(…)` cuando se llama una referencia a función. ## Resumen | Dentro del bloque de un `go` | Efecto | |---|---| | leer una variable de quien llama | permitido | | asignar una variable de quien llama | permitido: la cambia | | leer un alias | da el valor expuesto en ese `that` | | asignar a un alias | no cambia la función ni da error; crea una variable de quien llama con ese nombre | | modificar el objeto de un alias que es referencia | permitido: así responde el bloque | | `alias -> lista` | error: copie antes a una variable local | | `return valor` | sale de la función que contiene el `go` (en el nivel principal, termina el programa) | | `break` | rompe el ciclo de quien llama (sin ciclo, sale de la función con 0; en el nivel principal, termina el programa) | | error | lo atiende el `exception` de quien llama |