# Bloques de datos `$$ … $$` **Nuevo en 2.0.** Un bloque `$$ … $$` escribe una **lista** o un **registro** con notación tipo JSON dentro del `{ }` de `new`, `using`, `member` o `new member`. Reemplaza series de `@"k": v` y de `do list.add(...)`, y admite expresiones DKL como valores. Un programa que lo use no corre en Devkron 1.x. ```dkl a = "valor de a" new x {$$ 10, a, "pedro" $$} do print(to.json(x)) do print(list.count(x)) ``` ```text [10,"valor de a","pedro"] 3 ``` Un pedido con partidas, en varias líneas, y su total: ```dkl new pedido {$$ "cliente": "Juan", "fecha": "2026-10-23", "partidas": [ {"producto": "P-01", "cantidad": 2, "precio": 150.5}, {"producto": "P-02", "cantidad": 1, "precio": 99} ], "pagado": false, "notas": null $$} do print(to.json(pedido)) ref p = @@(pedido, "&partidas") total = 0 for i = 0; i < list.count(p) { ref it = list.obj(p, i) total = total + @@(it, "#cantidad") * @@(it, "#precio") } do print(total) ``` ```text {"cliente":"Juan","fecha":"2026-10-23","partidas":[{"producto":"P-01","cantidad":2,"precio":150.5},{"producto":"P-02","cantidad":1,"precio":99}],"pagado":false,"notas":null} 400.0 ``` ## ¿Lista o registro? La forma se decide **al analizar el archivo**, no al ejecutar: | Contenido del bloque | Resultado | |---|---| | un solo `{…}` | registro | | un solo `[…]` | lista (esa lista, no una lista que la contiene) | | empieza con `"clave":` | registro (llaves implícitas) | | cualquier otra cosa | lista (corchetes implícitos) | | vacío (`{$$ $$}`) | registro vacío, igual que `new x {}` | ```dkl new x {$$ 1, 2 $$} new y {$$ [1, 2] $$} new z {$$ [[1, 2]] $$} new w {$$ {"a": 1}, {"a": 2} $$} new v {$$ $$} new u {$$ [] $$} do print(to.json(x) + " " + to.json(y) + " " + to.json(z) + " " + to.json(w) + " " + to.json(v) + " " + to.json(u)) ``` ```text [1,2] [1,2] [[1,2]] [{"a":1},{"a":2}] {} [] ``` ## Valores - **Literales JSON**: cadenas `"…"` con escapes JSON (`\" \\ \/ \b \f \n \r \t \uXXXX`), números (también con exponente, `1e3`), `true`, `false`, `null` y `{…}` / `[…]` anidados. - **Cualquier expresión DKL**: variables, `@globales`, llamadas a funciones, aritmética, concatenación, comparaciones, rutas `x<"a/b">`. Se evalúan en el contexto actual, en orden. Las comas dentro de `()`, `[]`, `{}` y de cadenas no separan elementos. - **Comentarios** `//` y `/* … */` fuera de cadenas (un `//` dentro de una cadena, como en una URL, no es comentario). - **Claves**: siempre cadenas JSON entre comillas dobles. Si se repite una clave, gana el último valor. Se permite una coma final. ```dkl precio = 100 nombre = "Pedro" new r {$$ // comentario de línea "subtotal": precio, "iva": precio * 0.16, /* expresión DKL */ "texto": "Total: " + str(precio * 1.16), "mayor": precio > 50, "partes": [replace("a-b", "-", ","), trim(" " + nombre)], "url": "https://ejemplo.com/a//b", $$} do print(to.json(r)) ``` ```text {"subtotal":100,"iva":16.00,"texto":"Total: 116.00","mayor":1,"partes":["a,b","Pedro"],"url":"https://ejemplo.com/a//b"} ``` Tipos que produce el bloque (los mismos de `new` y `list.create`, así que `to.json`, `list.*`, `@@`, rutas `< >` y `record.*` funcionan igual): | Valor | Tipo .NET | |---|---| | registro | `Dictionary` **sin distinción de mayúsculas** (como `new`) | | lista | `List` (como `list.create`) | | número | `decimal` | | cadena | `string` | | `true` / `false` | `bool` (como `from.json`: `to.json` imprime `true`, `@@` da `1`) | | `null` | nulo | Una comparación DKL dentro del bloque (`"mayor": precio > 50`) da `1`/`0`, como en cualquier expresión, no `true`. Diferencias con `from.json` que se conservan a propósito: el registro de `$$` no distingue mayúsculas (el de `from.json` sí), y con una clave repetida se conserva la primera escritura de la clave con el último valor: ```dkl new r {$$ "Nombre": "Ana", "nombre": "Eva" $$} do print(to.json(r)) do print(@@(r, "NOMBRE")) ref j = from.json("{\"Nombre\":\"Ana\",\"nombre\":\"Eva\"}") do print(to.json(j)) ``` ```text {"Nombre":"Eva"} Eva {"Nombre":"Ana","nombre":"Eva"} ``` ## Variables, referencias y &expr | Escrito en el bloque | Se inserta | |---|---| | `a` (variable de valor) | su valor (cadena o número) | | `p` (identificador solo que es variable **de referencia**) | **el objeto mismo** (no una copia) | | `&expr` | el objeto cuyo índice devuelve `expr` (p. ej. `&devuelve(p)`) | | `expr` que devuelve un objeto (p. ej. `devuelve(p)`) | **su índice** (un número): use `&expr` | | referencia nula / `&nula` | `null` | ```dkl devuelve :: &o { return o } new p {$$ "id": 1 $$} new y {$$ "directo": p, "con_amp": &devuelve(p), "sin_amp": devuelve(p) $$} do print(to.json(y)) ``` ```text {"directo":{"id":1},"con_amp":{"id":1},"sin_amp":8} ``` El número de `sin_amp` es el índice del objeto en la tabla de objetos de la ejecución: por eso existe `&expr`. ## new, using, member y new member | Sentencia | Bloque con forma de **lista** | Bloque con forma de **registro** | |---|---|---| | `new x { $$…$$ }` | `x` es una lista nueva | `x` es un registro nuevo | | `using x { $$…$$ }` | agrega al final de la lista `x` (la crea si no existe o es nula) | agrega o reemplaza claves de `x` (lo crea si no existe) | | `member @"k" { $$…$$ }` | el miembro `k` es (o se vuelve) lista y se le agregan elementos | agrega o reemplaza claves del miembro | | `new member @"k" { $$…$$ }` | el miembro `k` es una lista nueva | el miembro `k` es un registro nuevo | Un bloque con forma de **registro** se puede mezclar con otras sentencias en el mismo `{ }` (y puede haber varios); se aplican en orden. El reemplazo de claves de `using` es **superficial**: `"sub": {…}` reemplaza el registro `sub` completo; para mezclar dentro de él use `member @"sub" {$$ … $$}`. ```dkl new m { @"folio": "A-1" $$ "cliente": "Juan", "partidas": [] $$ @"total": 0 } using m { $$ "total": 250, "estado": "abierto" $$ member @"partidas" {$$ [{"producto": "P-01"}] $$} new member @"envio" {$$ "ciudad": "Tuxtla" $$} } do print(to.json(m)) ``` ```text {"folio":"A-1","cliente":"Juan","partidas":[{"producto":"P-01"}],"total":250,"estado":"abierto","envio":{"ciudad":"Tuxtla"}} ``` Para agregar **un registro** a una lista hay que encerrarlo en `[ ]` (un solo `{…}` es un registro, no una lista): ```dkl ref l = list.create() for i = 1; i <= 3 { using l {$$ [{"i": i, "doble": i * 2}] $$} } do print(to.json(l)) ``` ```text [{"i":1,"doble":2},{"i":2,"doble":4},{"i":3,"doble":6}] ``` ## Errores Los errores de estructura se detectan **al cargar el archivo** (código `{132}`, con la línea dentro del bloque); los de tipos y expresiones, al ejecutar (se capturan con `exception { }` como cualquier otro). ```dkl ref l = list.create() using l {$$ {"i": 4} $$} exception { do print(last_error()) do clear_exceptions() } new r {$$ "a": 1 $$} using r {$$ 3 $$} ``` ```text {1} using 'l': la variable contiene una lista y el bloque $$ describe un registro (para agregar registros a la lista enciérrelos en [ ]) [ejemplo.dkl][Ln= 8] {1} using 'r': la variable contiene un registro y el bloque $$ describe una lista [ejemplo.dkl][Ln= 15] ``` ```dkl #include "dkli.dkh" #! program "ejemplo" { #include "functions.dkh" new x {$$ "a": 1, "b": "no cierra" } } ``` ```text {132} Error de sintaxis [/home/usuario/ejemplos/ejemplo.dkl] [132] - Bloque $$ sin terminar, falta el $$ de cierre[Ln= 7] ``` Otros mensajes: | Caso | Mensaje | |---|---| | JSON mal formado | `[132] - Bloque $$: se esperaba ':' después de la clave "b"` | | clave sin comillas | `[132] - Bloque $$: se esperaba una clave entre comillas dobles ("clave": valor)` | | escape inválido | `[132] - Bloque $$: secuencia de escape inválida '\q' en cadena` | | lista mezclada con otras sentencias | `[132] - Bloque $$: un bloque con forma de lista debe ser el único contenido del bloque de 'new'` | | bloque en contexto declarativo | `[132] - Bloque $$: solo se permite dentro del bloque { } de 'new', 'using', 'member' o 'new member' en contexto de interpretación` | | bloque con forma de registro suelto, al ejecutarse | `{1} Un bloque $$ con forma de registro debe estar dentro del cuerpo de 'new', 'using', 'member' o 'new member'` | | error en una expresión del bloque | `{1} Error en expresión: … (bloque $$, línea 36) [archivo][Ln= 32]` (`Ln` es la línea del `$$`; la línea exacta va en el texto) | ## Limitaciones - **No es una expresión**: `x = $$ 1, 2 $$` o `f($$ … $$)` no funcionan (dan `Operador inválido`). Solo es sentencia dentro de `new`/`using`/`member`/`new member`. - Un bloque con forma de **lista** debe ser el único contenido del `{ }`. - Las expresiones que devuelven objetos llegan como índice: use `&expr`. - Las claves deben ser literales; para claves calculadas siga usando `x: v`. - `{$$ "a": 1 // nota $$}` en **una sola línea** deja el bloque sin terminar: el comentario `//` llega al fin de línea y se come el `$$`. Un `/*` sin cerrar llega hasta el final del archivo. - Los escapes JSON (`á`) solo valen en literales JSON solos; dentro de una expresión DKL (`"á" + b`) manda el analizador de DKL, que no conoce `\u`. - Un `$$` fuera de una cadena siempre abre o cierra un bloque (no existen identificadores que empiecen con `$$`).