Roadmap Update Checklist / Registro de cierre

Este archivo registra los cierres que autorizan una actualización de docs/ROADMAP.md. Es parte del flujo de documentación: una delegación no está finalizada hasta que el registro y el roadmap reflejan el mismo estado.

Regla de cierre / Completion rule

Para cerrar un módulo, comprobar código, tests y README. Para cerrar una fase, comprobar además todos sus módulos requeridos. Solo después se cambia el estado en ROADMAP.md.

Cada entrada debe incluir la fecha, la fase, el módulo o conjunto de módulos, los lenguajes verificados, los comandos ejecutados y el cambio de estado realizado en el roadmap. No se deben inventar resultados.

Plantilla de registro / Entry template

Fecha / Date: YYYY-MM-DD
Fase / Phase: core.<phase>
Módulo(s) / Module(s): core.<phase>.<module>
Lenguaje(s) / Language(s): language-a, language-b
Código verificado / Code verified: yes/no
Tests y comandos / Tests and commands:
- `command` -> result
README(s) verificado(s) / README(s) verified: yes/no
Cambio en ROADMAP.md / ROADMAP.md change: old status -> new status
Observaciones / Notes:

Pendientes / Pending closures

Sin pendientes a 2026-09-28: la implementación, la documentación y el registro de cierre de core.algorithms.data_structures_basics (Clojure y COBOL) están completos.

Historial / History

Fecha / Date: 2026-10-17
Fase / Phase: core.algorithms
Módulo(s) / Module(s): core.algorithms.data_structures_basics (especificación 06_Data_Structures_Basics)
Lenguaje(s) / Language(s): 50 auditados; 10 con hallazgo corregido (ocaml, groovy, nim, common-lisp, fsharp, haskell, haxe, php, purescript, python)
Código verificado / Code verified: yes (auditoría en docs/audits/06_Audited_Data_Structures_Basics.md)
Tests y comandos / Tests and commands:
- Las 50 suites del catálogo -> 50/50 rc=0
- Re-ejecución sobre el `main` integrado de los diez -> `dune runtest --force` 4 tests; `dotnet test` 23; groovy 4 (XML); `cabal test` PASS; haxe 4 bloques; `nimble test` todas; `composer test` 4 tests y 15 aserciones; `spago test` 5; `pytest` 4; common-lisp 15 comprobaciones
README(s) verificado(s) / README(s) verified: yes (los 50 README del módulo contra la plantilla de Nivel 3; `groovy` declara `lib/bin` como salida generada y `common-lisp` deja un solo README)
Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics sigue en ✅ 50/50; se añade a la nota del módulo el cierre de la auditoría 06 (el contador del sprint no se toca)
Observaciones / Notes: Cierre de la pasada 06. El pase verificó las 50 implementaciones (un solo `Node` compartido, sin delegación entre estructuras ni colecciones de biblioteca, `init` antes de `is_empty`, indicador por tipo de retorno, `O(1)` salvo `delete` y los 15 pasos de caso) y dejó 10 hallazgos, todos corregidos e integrados en 10 commits de `align`. `ocaml` devolvía `int option` en las cuatro lecturas: se comprobó en la documentación oficial que era convención y no restricción del lenguaje, y pasa al centinela `-1` dejando `option` solo en los enlaces. Además, `lib/bin` de `groovy` y el binario `.out` de `nim` salen del índice, `common-lisp` queda con un README y ocho lenguajes pierden sus cabeceras de andamiaje del paso 4b.

Fecha / Date: 2026-10-17
Fase / Phase: core.algorithms
Módulo(s) / Module(s): core.algorithms.naive_sort (especificación 05_Naive_Sort)
Lenguaje(s) / Language(s): 50 auditados; 4 con hallazgo corregido (ocaml, scheme, haskell, cobol)
Código verificado / Code verified: yes (auditoría en docs/audits/05_Audited_Naive_Sort.md)
Tests y comandos / Tests and commands:
- Las 50 suites del catálogo antes del `align` -> 49 rc=0; `ocaml` rc=1 (`Module "Main" doesn't exist`)
- Re-ejecución sobre el `main` integrado -> `dune runtest --force` 3 tests; suite de Guile 24 comprobaciones; `cabal test` PASS; `make test` de `cobol` 78/78
README(s) verificado(s) / README(s) verified: yes (los 50 README del módulo contra la plantilla de Nivel 3; `cobol` documenta la representación equivalente de la entrada inválida)
Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort sigue en ✅ 50/50; se añade a la nota del módulo el cierre de la auditoría 05 (el contador del sprint no se toca)
Observaciones / Notes: Cierre de la pasada 05. El pase verificó las 50 implementaciones (los tres algoritmos, corte temprano real de la burbuja, indicador de fallo, los 7 casos sobre fixture nuevo y la separación código/pruebas) y dejó 4 hallazgos, todos corregidos e integrados en 4 commits de `align`: el `bin/dune` huérfano de `ocaml` (tercera aparición del caso), `(apply min …)` de biblioteca en `scheme`, un `error` inalcanzable en `haskell` y la representación de entrada inválida sin documentar en `cobol`. Se retiró un hallazgo provisional: el `.github/workflows/test.yml` de `gleam` es convención de sus cinco módulos. Al abrir el pase se corrigieron tres criterios de la especificación: el indicador de fallo sin `Option`/`Result`, la prohibición de `min`/`max` anclada al enunciado y las dos formas de mutación marcadas con `✅`.

Fecha / Date: 2026-10-16
Fase / Phase: core.foundations
Módulo(s) / Module(s): core.foundations.numbers (especificación 04_Numbers)
Lenguaje(s) / Language(s): 50 auditados; 7 con hallazgo corregido (ballerina, clojure, crystal, dart, elm, ocaml, tcl-tk)
Código verificado / Code verified: yes (auditoría en docs/audits/04_Audited_Numbers.md)
Tests y comandos / Tests and commands:
- Los comandos del catálogo sobre el `main` integrado de los siete -> 8/8 rc=0 (clojure: 33 aserciones; elm: 33 pruebas; crystal y dart: 10 cada uno; tcl-tk: Total 11 Passed 11 por suite)
- `dune runtest` en `ocaml/` -> rc=0 tras añadir `bin/main.ml`; `dune exec numbers` imprime los cinco resultados
README(s) verificado(s) / README(s) verified: yes (los 50 README del módulo contra la plantilla de Nivel 3; `elm` reestructurado y `tcl-tk` con la cabecera de compilación restaurada)
Cambio en ROADMAP.md / ROADMAP.md change: core.foundations.numbers sigue en ✅ 50/50; la nota del módulo pasa a nombrar la auditoría 04 cerrada (el contador del sprint no se toca)
Observaciones / Notes: Cierre de la pasada 04. El pase verificó las 50 implementaciones (los cinco algoritmos en las variantes que cada lenguaje permite, con la combinación de suites declarada en el README y los 11 casos por variante cubiertos) y dejó 7 hallazgos, todos corregidos e integrados en 7 commits de `align`. Dos hallazgos provisionales se retiraron al comprobarlos: `ada` (sus tres suites llevan 11 aserciones agrupadas en 5 procedimientos de AUnit) y `common-lisp` (su `run-tests` sí ejecuta las tres suites: 33 checks).

Fecha / Date: 2026-10-14
Fase / Phase: core.foundations
Módulo(s) / Module(s): core.foundations.hello_user (especificación 02_Hello_User)
Lenguaje(s) / Language(s): 50 auditados; 32 con hallazgo corregido (11 de prompt/saludo y 20 de nombre de fichero, con solapes) y `grain` aceptado
Código verificado / Code verified: yes (auditoría en docs/audits/02_Audited_Hello_User.md)
Tests y comandos / Tests and commands:
- Los comandos documentados por módulo, con la entrada `John` (`Ada` en `rexx`) -> 49/50 rc=0; `grain` no tiene módulo porque el lenguaje no lee de stdin
- Re-ejecución tras los arreglos -> 49/50 rc=0 con la salida del criterio
README(s) verificado(s) / README(s) verified: yes (los 50 README del módulo contra la plantilla de Nivel 3)
Cambio en ROADMAP.md / ROADMAP.md change: core.foundations.hello_user sigue en ✅ 50/50; la nota del módulo pasa a nombrar la auditoría 02 cerrada (el contador del sprint no se toca)
Observaciones / Notes: Cierre de la pasada 02. Criterio del módulo corregido durante el pase: el prompt de la especificación pasó de «What is your name?» a «Enter your name: », porque el autor lo había documentado mal; el cambio quedó anotado con fecha en la especificación y en los documentos afectados. Desviación aceptada: `grain` no tiene stdin, así que el módulo interactivo no existe (docs/ruleset/idioms/grain.md). Se corrigieron además `rexx` (`parse pull` en vez de `pull`, que pasa el texto a mayúsculas), `rescript` (`Js.log` con concatenación, porque `Js.log3` inserta espacios) y `forth` (una línea suelta que rompía la ejecución). 34 commits en 32 submódulos, integrados y empujados.

Fecha / Date: 2026-10-13
Fase / Phase: core.foundations
Módulo(s) / Module(s): core.foundations.hello_world (especificación 01_Hello_World)
Lenguaje(s) / Language(s): 50 auditados; 35 con hallazgo corregido (34 del módulo y `haxe`)
Código verificado / Code verified: yes (auditoría en docs/audits/01_Audited_Hello_World.md)
Tests y comandos / Tests and commands:
- La ejecución del programa en los 50 lenguajes con su comando documentado -> 50/50 rc=0
- Re-ejecución tras los arreglos -> 50/50 rc=0, con el mensaje exacto salvo `elm` (`: ()`), `r` (`[1] "…"`) y `zig` (que lo escribe por stderr)
README(s) verificado(s) / README(s) verified: yes (los 50 README del módulo contra la plantilla de Nivel 3; 5 completados y 14 citas del mensaje corregidas)
Cambio en ROADMAP.md / ROADMAP.md change: core.foundations.hello_world sigue en ✅ 50/50; la nota del módulo pasa a nombrar la auditoría 01 cerrada (el contador del sprint no se toca)
Observaciones / Notes: Cierre de la pasada 01. 40 commits de `align` (21 por el mensaje exacto y 20 por el nombre del fichero, 7 en las dos listas) y 27 de corrección en una segunda pasada (impresión en `r`, `racket` y `zig`, `.gitignore` de artefactos en 14 lenguajes, 5 READMEs y el nombre del paquete de `purescript`). Desviación aceptada: `elm` no tiene salida por consola en su biblioteca estándar y usa `Debug.log` (docs/ruleset/idioms/elm.md).

Fecha / Date: 2026-10-16
Fase / Phase: core.foundations
Módulo(s) / Module(s): core.foundations.unit_test (especificación 03_Unit_Test_Calculator)
Lenguaje(s) / Language(s): 50 auditados; 15 con hallazgo corregido (ballerina, clojure, common-lisp, cpp, crystal, csharp, dart, erlang, fsharp, forth, grain, julia, ocaml, scheme, tcl-tk)
Código verificado / Code verified: yes (auditoría en docs/audits/03_Audited_Unit_Test_Calculator.md)
Tests y comandos / Tests and commands:
- Los 15 comandos del catálogo sobre el `main` integrado -> 15/15 rc=0 con 5 pruebas cada uno
- `dune runtest` en `ocaml/` -> rc=0 tras añadir `bin/main.ml`; `dune exec test/test_calculator.exe` -> `Test Successful in 0.001s. 5 tests run.`
README(s) verificado(s) / README(s) verified: yes (los 50 README del módulo contra la plantilla de Nivel 3: 50/50 con las cuatro secciones aplicables)
Cambio en ROADMAP.md / ROADMAP.md change: core.foundations.unit_test sigue en ✅ 50/50; se añade a la nota del módulo el cierre de la auditoría 03 (el contador del sprint no se toca)
Observaciones / Notes: Cierre de la pasada 03. El pase verificó las 50 implementaciones (cinco operaciones, multiplicación por suma repetitiva, división por resta repetitiva y módulo construido con ambas, solo biblioteca estándar) y dejó 15 hallazgos, todos corregidos e integrados: 5 de nombres, 6 de comentarios de plantilla, 3 de cabeceras de README y el `bin/dune` huérfano de `ocaml`. Cuatro hallazgos se retiraron al comprobar la convención en el módulo hermano homologado `04_Numbers` (`src` como módulo o paquete en `v`, `go` y `haxe`, `*_base.dart` en `dart` y `testify` en `go`). Deuda heredada por la auditoría 04: los mismos placeholders de plantilla y el mismo `bin/dune` huérfano en `04_Numbers`.

Fecha / Date: 2026-09-28
Fase / Phase: core.algorithms
Módulo(s) / Module(s): core.algorithms.data_structures_basics
Lenguaje(s) / Language(s): cobol
Código verificado / Code verified: yes
Tests y comandos / Tests and commands:
- `make clean && make build` en `cobol/core/algorithms/data_structures_basics` -> exit 0, sin warnings (GnuCOBOL, formato libre)
- `make test` -> `Total: 049 / Passed: 049 / Failed: 000 / >>> ALL TESTS PASSED <<<`
README(s) verificado(s) / README(s) verified: yes (cobol/core/algorithms/data_structures_basics/README.md)
Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 5/50 (Ada, Assembly, Ballerina, C, Clojure) -> 6/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL)
Observaciones / Notes: Sexta implementación homologada de data_structures_basics. No cierra el módulo: faltan los demás lenguajes. COBOL es procedimental sin objetos: el contrato se declara como un conjunto de subprogramas PROGRAM-ID compilados en el mismo archivo fuente; la familia idiomática es «C, Assembly, COBOL, Forth» según AGENT_Template.md. Los nodos se gestionan con ALLOCATE/FREE (ISO COBOL 2002+) y el tipo DS-NODE es BASED; el acceso a campos usa SET ADDRESS OF DS-NODE TO <puntero>. Ausencia nativa de puntero: NULL. Indicador de fallo numérico: -1 (DS-FAILURE-VALUE, PIC S9(9)). Los booleanos se representan con PIC 9 (1 = vacía, 0 = no vacía). No hay framework de pruebas externo: la suite es artesanal con contadores propios en RUN-TESTS.cbl. No se usa recursión (COBOL tiene soporte limitado); todos los recorridos son iterativos con PERFORM UNTIL. Los índices Nivel 2 (algorithms/README.md), Nivel 1 (core/README.md y cobol/README.md) se actualizaron en el mismo cambio.

Fecha / Date: 2026-09-28
Fase / Phase: core.algorithms
Módulo(s) / Module(s): core.algorithms.data_structures_basics
Lenguaje(s) / Language(s): clojure
Código verificado / Code verified: yes
Tests y comandos / Tests and commands:
- `clojure -M -e "(require 'data-structures-basics.data-structures-basics)"` -> exit 0, sin warnings
- `clojure -M:test -m cognitect.test-runner` -> `Ran 4 tests containing 46 assertions. 0 failures, 0 errors.`
README(s) verificado(s) / README(s) verified: yes (clojure/core/algorithms/data_structures_basics/README.md)
Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 4/50 (Ada, Assembly, Ballerina, C) -> 5/50 (Ada, Assembly, Ballerina, C, Clojure)
Observaciones / Notes: Quinta implementación homologada de data_structures_basics. No cierra el módulo: faltan los demás lenguajes. Clojure es funcional e inmutable: `defrecord` crea tipos de valor, cada operación devuelve una nueva instancia, y `pop`/`dequeue` devuelven un mapa `{:stack/:queue …, :value …}` para proporcionar ambos — la estructura actualizada y el valor extraído — sin mutación. `ll-insert-tail` y `queue-enqueue` son O(n) en lugar de O(1) porque el nodo existente en cola no puede enlazarse en su lugar. Los getters/setters del pseudocódigo se expresan como acceso por keyword (`:value`, `:next`) y `assoc` respectivamente, que es la forma idiomática de los campos de un `defrecord`. No se añade `interface`/`protocol`: la especificación (Fase 1) y AGENT_Template.md prohíben el contrato aparte mientras haya una sola implementación. Los índices Nivel 2 (algorithms/README.md), Nivel 1 (core/README.md y clojure/README.md) se actualizaron en el mismo cambio.

Fecha / Date: 2026-09-21
Fase / Phase: core.algorithms
Módulo(s) / Module(s): core.algorithms.naive_sort
Lenguaje(s) / Language(s): 50 (auditados); 6 arreglos de fidelidad o de tests (racket, cpp, csharp, clojure, swift, tcl-tk) y 8 de comentarios (java, dart, haskell, elm, erlang, haxe, common-lisp, cpp)
Código verificado / Code verified: yes (auditoría en docs/audits/05_Audited_Naive_Sort.md)
Tests y comandos / Tests and commands:
- `raco make ... && racket test/run_tests.rkt` en `racket/` -> `3 success(es) 0 failure(s) 0 error(s) 3 test(s) run` tras el refactor a vectores
- `bazelisk test //:naive_sort_tests --test_output=summary` en `cpp/` -> `PASSED in 0.0s`, `Executed 1 out of 1 test: 1 test passes` tras añadir el guardia `min_idx != i`
- `dotnet test NaiveSort.slnx` en `csharp/` -> `Passed! - Failed: 0, Passed: 3, Skipped: 0, Total: 3` tras clonar los fixtures
- `clojure -T:build test` en `clojure/` -> `Ran 6 tests containing 48 assertions. 0 failures, 0 errors.` (valida el arreglo pendiente de commit)
- `TCLLIBPATH="$(cd ../src && pwd)" tclsh9.0 naive_sort.test` en `tcl-tk/test` -> `Total 21 Passed 21 Skipped 0 Failed 0` (valida el arreglo pendiente de commit)
- `swift test` en `swift/` -> `Executed 3 tests, with 0 failures (0 unexpected)` (valida el arreglo pendiente de commit)
- Barrido léxico en los 50 lenguajes (solo archivos rastreados por git) -> 0 invocaciones de ordenamiento de biblioteca y 0 retornos monádicos o excepciones como contrato
README(s) verificado(s) / README(s) verified: yes (50/50 con las tres secciones obligatorias de `README_Template.md`)
- Integración: `git -C <lenguaje> log --oneline -2` y `git submodule status cpp csharp racket swift tcl-tk clojure` -> merges `refactor/naive-sort` en el `main` de los 6 submódulos y punteros del monorepo apuntando a ellos
- Criterio 4 (comentarios): 8 lenguajes corregidos y verificados -> `mvn test` en `java/` -> `Tests run: 3, Failures: 0, Errors: 0` y `BUILD SUCCESS`; `dart test` en `dart/` -> `+3: All tests passed!`; `elm-test` en `elm/` -> `TEST RUN PASSED`, `Passed: 21`, `Failed: 0`; `cabal test --test-show-details=direct` en `haskell/` -> `21 examples, 0 failures`; `rebar3 eunit` en `erlang/` -> `21 tests, 0 failures`; `haxe build.hxml` en `haxe/` -> `results: ALL TESTS OK (success: true)`; `ros run --load run-tests.lisp --eval '(uiop:quit)'` en `common-lisp/` -> `Pass: 24 (100%)`, `Fail: 0 ( 0%)`; `bazelisk test //:naive_sort_tests --nocache_test_results` en `cpp/` -> `PASSED`, `1 test passes`
- Generadores formales tras la corrección: `grep` en los 9 archivos tocados -> 0 coincidencias (`@param`, `{@code}`, `///`, `/**`, `-- \|`, `{- \|`)
- Ada (tras restaurar `alr` con `~/temp/fix-alr.sh`): `alr -C test run` en `ada/` -> `Total Tests Run: 3`, `Successful Tests: 3`, `Failed Assertions: 0`, `Unexpected Errors: 0`
Cambio en ROADMAP.md / ROADMAP.md change: Foundations 49/49 -> 50/50; `core.algorithms.naive_sort` 49/49 -> 50/50; leyenda y contadores `X/49` -> `X/50`; `php` añadido a la lista de lenguajes del módulo
Observaciones / Notes: `php` entra en el contador como quincuagésimo submódulo (cierra la decisión abierta del cierre anterior del 2026-09-20) y `core.algorithms.naive_sort` queda cerrado en 50/50. Los seis arreglos de fidelidad o de tests y los ocho de comentarios (criterio 4) están aplicados y verificados con la suite de cada lenguaje, y el resto de suites del módulo se ejecutó el 2026-09-21 (42 más, todas en verde, incluida la de Ada con `alr -C test run` tras restaurar el binario con `~/temp/fix-alr.sh`). El detalle vive en `docs/audits/05_Audited_Naive_Sort.md`.

Fecha / Date: 2026-09-11 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): ada Código verificado / Code verified: yes Tests y comandos / Tests and commands:

alr -C test run en ada/core/algorithms/naive_sort -> 3 tests ejecutados, 3 exitosos, 0 aserciones fallidas, 0 errores inesperados README(s) verificado(s) / README(s) verified: yes (ada/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 📋 -> 🔄 (1/49) Observaciones / Notes: Primera implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. En Ada no existe representación de array nulo, por lo que el escenario inválido de la especificación queda documentado como no representable.

Fecha / Date: 2026-09-12 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): assembly Código verificado / Code verified: yes (bugs corregidos: sintaxis GAS en vez de NASM, rsi/esi reutilizado para la bandera swapped en bubble_sort, límite fuera de uno en el bucle interno de bubble_sort, rbx sin preservar, rax sin fijar en los casos vacío/un elemento) Tests y comandos / Tests and commands:

make run en assembly/core/algorithms/naive_sort -> 24 tests ejecutados, 24 exitosos, 0 fallidos README(s) verificado(s) / README(s) verified: yes (assembly/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 1/49 (Ada) -> 2/49 (Ada, Assembly) Observaciones / Notes: Segunda implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. A diferencia de Ada, en Assembly el array es un puntero crudo, por lo que null sí es representable; se añadió un octavo caso de prueba (puntero nulo) además de los 7 del enunciado.

Fecha / Date: 2026-09-12 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): ballerina Código verificado / Code verified: yes Tests y comandos / Tests and commands:

bal test en ballerina/core/algorithms/naive_sort -> 3 tests ejecutados, 3 exitosos, 0 fallidos (24 aserciones)
Prueba negativa: con insertionSort invertido -> 2 passing, 1 failing, confirmando que la suite detecta fallos README(s) verificado(s) / README(s) verified: yes (ballerina/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 2/49 (Ada, Assembly) -> 3/49 (Ada, Assembly, Ballerina) Observaciones / Notes: Tercera implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Ballerina no admite int[] nulo, pero sí el tipo nillable int[]?, que se usa como indicador de fallo; se añadió el octavo caso (()). El clonado es responsabilidad de la implementación, por lo que los fixtures compartidos se pasan como entradas de solo lectura sin clonar en el test.

Fecha / Date: 2026-09-12 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): c Código verificado / Code verified: yes Tests y comandos / Tests and commands:

make test en c/core/algorithms/naive_sort (compilación limpia, sin warnings con -Wall -Wextra -std=c99) -> Tested: 3 | Passing: 3 | Failing: 0 | Crashing: 0 (24 aserciones)
Prueba negativa: con la comparación de insertion_sort invertida -> Passing: 2 | Failing: 1, confirmando que la suite detecta fallos README(s) verificado(s) / README(s) verified: yes (c/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 3/49 (Ada, Assembly, Ballerina) -> 4/49 (Ada, Assembly, Ballerina, C) Observaciones / Notes: Cuarta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. En C el ordenamiento es in-place (paradigma del lenguaje, permitido por la especificación); el indicador de fallo es NULL y se añadió el octavo caso (arr = NULL). Las pruebas copian cada fixture a un buffer scratch con memcpy porque los fixtures son const y compartidos entre los tres algoritmos.

Fecha / Date: 2026-09-12 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): clojure Código verificado / Code verified: yes Tests y comandos / Tests and commands:

clojure -T:build test en clojure/core/algorithms/naive_sort -> Ran 3 tests containing 24 assertions. 0 failures, 0 errors.
Verificación previa en copia desechable fuera del repositorio, para no tocar src/ durante la generación de tests: implementación funcional correcta -> 0 failures; implementación rota a propósito -> 3 failures con mensajes como insertion-sort should sort negative values README(s) verificado(s) / README(s) verified: yes (clojure/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 4/49 (Ada, Assembly, Ballerina, C) -> 5/49 (Ada, Assembly, Ballerina, C, Clojure) Observaciones / Notes: Quinta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. La realización difiere de la establecida en la especificación: Clojure es funcional y su idioma evita la mutación, así que las tres funciones devuelven siempre una colección nueva en lugar de ordenar in-place; el concepto algorítmico es el mismo. El indicador de fallo es nil (valor válido en Clojure) y se añadió el octavo caso. El runner nativo ya existía (build.clj -> cognitect.test-runner), por lo que no se generó un archivo de ejecución aparte.

Fecha / Date: 2026-09-13 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): cobol Código verificado / Code verified: yes Tests y comandos / Tests and commands:

make clean && make && ./run_tests en cobol/core/algorithms/naive_sort -> 78 tests ejecutados, 78 exitosos, 0 fallidos README(s) verificado(s) / README(s) verified: yes (cobol/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 5/49 (Ada, Assembly, Ballerina, C, Clojure) -> 6/49 (Ada, Assembly, Ballerina, C, Clojure, COBOL) Observaciones / Notes: Sexta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. COBOL es un lenguaje orientado a procedimientos que no soporta recursión de forma natural. Todos los algoritmos se implementaron de manera iterativa. El manejo de arrays se realiza mediante estructuras con cláusulas OCCURS. La implementación sigue el patrón de devolver un código de retorno (RETURN-CODE) para indicar éxito o fracaso.

Fecha / Date: 2026-09-13 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): common-lisp Código verificado / Code verified: yes Tests y comandos / Tests and commands:

ros run --load run-tests.lisp --eval '(uiop:quit)' en common-lisp/core/algorithms/naive_sort -> Running test suite NAIVE-SORT-SUITE ... Did 24 checks. Pass: 24 (100%) Skip: 0 (0%) Fail: 0 (0%)
(asdf:test-system :naive-sort) (vía ASDF) -> mismos resultados, 24 checks
Prueba negativa: con la comparación de la suite devolviendo siempre nil -> 24 fallos, confirmando que la suite detecta fallos README(s) verificado(s) / README(s) verified: yes (common-lisp/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 6/49 (Ada, Assembly, Ballerina, C, Clojure, COBOL) -> 7/49 (Ada, Assembly, Ballerina, C, Clojure, COBOL, Common Lisp) Observaciones / Notes: Séptima implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. La realización difiere del pseudocódigo por convención del lenguaje: Common Lisp es funcional y su idioma evita la mutación, así que las tres funciones devuelven una copia ordenada en lugar de ordenar in-place (la especificación permite ambas variantes). El indicador de fallo es nil (valor válido en Common Lisp) y se añadió el octavo caso controlado (nil -> nil), ya que el lenguaje puede representarlo. El sistema base no tiene dependencias externas; se eliminó alexandria, que estaba declarada pero sin usar, y fiveam se usa solo en el sistema de pruebas. Las aserciones usan equalp en vez de equal, porque equal no compara vectores generales elemento a elemento. El runner nativo funciona con (asdf:test-system :naive-sort) gracias al test-op declarado en naive-sort.asd.

Fecha / Date: 2026-09-13 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): cpp Código verificado / Code verified: yes (mitigación aplicada: bubble_sort no incluía la salida temprana con bandera swapped exigida por los criterios de aceptación; se añadió y se re-verificó) Tests y comandos / Tests and commands:

bazelisk test //... en cpp/core/algorithms/naive_sort -> [==========] 3 tests from 1 test suite ran. [ PASSED ] 3 tests. (21 aserciones: 7 casos × 3 algoritmos)
g++ -std=c++17 -Wall -Wextra -Wpedantic -Iinclude -c src/naive_sort.cpp -> sin warnings README(s) verificado(s) / README(s) verified: yes (cpp/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 7/49 (Ada, Assembly, Ballerina, C, Clojure, COBOL, Common Lisp) -> 8/49 (Ada, Assembly, Ballerina, C, Clojure, COBOL, Common Lisp, C++) Observaciones / Notes: Octava implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Verificación previa al README: se comparó la implementación con el pseudocódigo y se detectó que bubble_sort omitía la salida temprana con bandera swapped (criterio de aceptación de 05_Naive_Sort.md), lo que degradaba el mejor caso a O(n²); se notificó al desarrollador y se mitigó antes de generar el README. Las demás divergencias no son funcionales: las funciones reciben el vector por valor y devuelven una copia ordenada (la especificación permite in-place o copia), y selection_sort siempre intercambia, lo que equivale al guardas if (min_idx != i) del pseudocódigo. El caso nulo no es representable con std::vector<int> por valor; se documenta como no representable y se conservan los 7 casos canónicos. La implementación compila sin warnings con -Wall -Wextra -Wpedantic.

Fecha / Date: 2026-09-13 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): crystal Código verificado / Code verified: yes (corrección aplicada: eliminado return nil if arr.nil? de los tres algoritmos y corregida la sintaxis de lambda en tests) Tests y comandos / Tests and commands:

crystal spec en crystal/core/algorithms/naive_sort -> 3 tests ejecutados, 3 exitosos, 0 fallidos (21 aserciones: 7 casos × 3 algoritmos)
crystal build src/naive_sort.cr -> sin warnings ni errores README(s) verificado(s) / README(s) verified: yes (crystal/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 8/49 (Ada, Assembly, Ballerina, C, Clojure, COBOL, Common Lisp, C++) -> 9/49 (Ada, Assembly, Ballerina, C, Clojure, COBOL, Common Lisp, C++, Crystal) Observaciones / Notes: Novena implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Crystal es un lenguaje orientado a objetos con tipado estático inferido. Los tres algoritmos operan in-place sobre el array recibido (paradigma imperativo del lenguaje, permitido por la especificación). El tipo Array(Int32) no permite nil, por lo que el caso de entrada nula no es representable y se documenta como tal. Todos los algoritmos usan iteración (bucles each, loop, while) siguiendo el estilo idiomático de Crystal, que no garantiza TCO. Las pruebas usan el framework estándar spec de Crystal y clonan los fixtures con .dup para evitar efectos secundarios al ordenar in-place.

Fecha / Date: 2026-09-14 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): csharp Código verificado / Code verified: yes (mitigación aplicada: las firmas de SelectionSort, BubbleSort e InsertionSort declaraban int[] no anulable pese a comprobar arr == null, lo que producía CS8603 en src/ y CS8622 al pasar los métodos a Func<int[]?, int[]?> en los tests; se cambiaron parámetro y retorno a int[]? y se re-verificó) Tests y comandos / Tests and commands:

dotnet build NaiveSort.slnx en csharp/core/algorithms/naive_sort -> build correcto, 0 warnings, 0 errores
dotnet test NaiveSort.slnx -> Test summary: total: 3, failed: 0, succeeded: 3, skipped: 0, duration: 0.7s (24 aserciones: 8 casos × 3 algoritmos) README(s) verificado(s) / README(s) verified: yes (csharp/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 9/49 (Ada, Assembly, Ballerina, C, Clojure, COBOL, Common Lisp, C++, Crystal) -> 10/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal) Observaciones / Notes: Décima implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. C# tiene los nullable reference types habilitados (<Nullable>enable</Nullable>), por lo que el indicador de fallo null exige declarar parámetro y retorno como int[]?; se añadió el octavo caso controlado (null -> null). Los tres algoritmos ordenan in-place (paradigma imperativo, permitido por la especificación). La clase se llama NaiveSortImpl para no chocar con el namespace NaiveSort. El runner es dotnet test sobre la solución .slnx; no se generó un archivo de ejecución aparte porque .NET descubre automáticamente los [Fact]. Se añadió .gitignore del módulo, pero permanecen 25 archivos bin//obj/ ya rastreados en el índice anteriores a su creación.

Fecha / Date: 2026-09-14 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): d Código verificado / Code verified: yes Tests y comandos / Tests and commands:

dub test en d/core/algorithms/naive_sort -> 1 modules passed unittests (3 bloques unittest, 24 aserciones: 8 casos × 3 algoritmos)
dmd -c -o- -w -wi source/naive_sort.d -> sin salida, exit 0 (compila sin warnings) README(s) verificado(s) / README(s) verified: yes (d/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 10/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal) -> 11/49 (…, C++, Crystal, D) Observaciones / Notes: Undécima implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Los arrays de D son slices (puntero + longitud), por lo que null es representable y se añadió el octavo caso (null -> null). Los tres algoritmos ordenan in-place sobre el slice recibido (idiomático en D). insertionSort usa size_t y la variante de desplazamiento while (j > 0 && arr[j - 1] > key), equivalente al pseudocódigo sin índice con signo. El paquete se configuró como targetType "library" y se eliminó el source/app.d generado por dub init porque su void main() choca con el runner de dub test (only one entry point 'main' is allowed). Los fixtures del test son static immutable y cada caso ordena una copia con .dup.

Fecha / Date: 2026-09-14 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): dart Código verificado / Code verified: yes (mitigación aplicada: el scaffold de dart create en example/naive_sort_example.dart seguía referenciando la clase Awesome, eliminada al implementar NaiveSort, y hacía fallar dart analyze con undefined_function; se actualizó el ejemplo a una llamada real a NaiveSort.selectionSort) Tests y comandos / Tests and commands:

dart test en dart/core/algorithms/naive_sort -> 00:00 +3: All tests passed! (3 tests, 8 casos × 3 algoritmos = 24 aserciones)
dart analyze -> No issues found! (exit 0) README(s) verificado(s) / README(s) verified: yes (dart/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 11/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D) -> 12/49 (…, D, Dart) Observaciones / Notes: Duodécima implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. El parámetro y el retorno son List<int>? porque null es el indicador de fallo del lenguaje, y se añadió el octavo caso (null -> null). Los tres algoritmos ordenan in-place sobre la lista recibida (idiomático en Dart). La clase NaiveSort agrupa métodos static, siguiendo la convención de Numbers en numbers/. Los fixtures del test son const y cada caso ordena una copia con List<int>.of, evitando que la mutación in-place contamine los demás casos o falle contra una lista inmutable. dart analyze usa package:lints/recommended.yaml vía analysis_options.yaml.

Fecha / Date: 2026-09-14 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): elixir Código verificado / Code verified: yes (mitigaciones aplicadas: en lib/naive_sort.ex:38, {swapped, rest} = bubble_pass([a | tail]) declaraba una variable swapped sin usar, que hacía fallar mix compile --warnings-as-errors; se renombró a _swapped. Además lib/naive_sort.ex no cumplía mix format --check-formatted por líneas en blanco sobrantes; se aplicó mix format) Tests y comandos / Tests and commands:

mix compile --force --warnings-as-errors en elixir/core/algorithms/naive_sort -> Compiling 1 file (.ex) y Generated naive_sort app (exit 0, 0 warnings)
mix format --check-formatted -> sin archivos pendientes (exit 0)
mix test -> Finished in 0.01 seconds (0.00s async, 0.01s sync) y Result: 3 passed (3 tests, 8 casos × 3 algoritmos = 24 aserciones) README(s) verificado(s) / README(s) verified: yes (elixir/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 12/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart) -> 13/49 (…, D, Dart, Elixir) Observaciones / Notes: Decimotercera implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Elixir no tiene bucles imperativos ni listas mutables, así que los tres algoritmos son recursivos y devuelven una lista nueva: el swap in-place del pseudocódigo no es representable (divergencia idiomática aceptada). La bandera swapped de bubble_sort se conserva como el valor de retorno de bubble_pass/1, que empaqueta {swapped, lista}, manteniendo la salida temprana. nil es el indicador de fallo y se retorna como valor, con el octavo caso assert sort_function.(nil) == nil. Los casos base [] y [a] se resuelven por cláusulas en lugar de un if n <= 1. Ubicación desviada de la especificación: el código va en lib/ (convención de Mix) y no hay run_tests.exs porque ExUnit incorpora su propio runner vía mix test. El índice de fase elixir/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-15 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): elm Código verificado / Code verified: yes (mitigación aplicada: el listado exposing de src/NaiveSort.elm estaba sin cerrar, lo que producía UNFINISHED EXPOSING y hacía fallar elm make y elm-test con exit 1; se añadió el paréntesis de cierre) Tests y comandos / Tests and commands:

elm make src/NaiveSort.elm --output=/dev/null en elm/core/algorithms/naive_sort -> Success! Compiled 1 module. (exit 0)
elm-test -> TEST RUN PASSED, Duration: 117 ms, Passed: 21, Failed: 0 (3 algoritmos × 7 casos) README(s) verificado(s) / README(s) verified: yes (elm/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 13/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir) -> 14/49 (…, Elixir, Elm) Observaciones / Notes: Decimocuarta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Elm no tiene bucles imperativos ni listas mutables, así que los tres algoritmos son recursivos y devuelven una lista nueva: el swap in-place del pseudocódigo no es representable (divergencia idiomática aceptada). La bandera swapped se devuelve como parte de un par (bubblePass : List Int -> (List Int, Bool)), conservando la salida temprana. pickMin reconstruye la lista restante en un orden distinto al original, sin efecto observable porque se vuelve a ordenar de inmediato. Caso nulo omitido: Elm no tiene null/nil y List Int no admite entradas inválidas; el criterio «sin lanzar excepciones» se cumple porque Elm no tiene excepciones. Ubicación desviada de la especificación: el archivo debe llamarse NaiveSort.elm (PascalCase, igual que el módulo), el directorio de pruebas es tests/ en plural y no hay run_tests.elm porque elm-test descubre las suites automáticamente. elm.json declara elm-explorations/test en test-dependencies, no en dependencies. El índice de fase elm/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-15 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): erlang Código verificado / Code verified: yes (sin mitigaciones: rebar3 compile sin warnings y rebar3 eunit en verde tras implementar el módulo, que partía del esqueleto -export([]). de rebar3 new lib) Tests y comandos / Tests and commands:

rebar3 compile en erlang/core/algorithms/naive_sort -> ===> Compiling naive_sort (exit 0, 0 warnings)
rebar3 eunit -> Finished in 0.068 seconds y 21 tests, 0 failures (exit 0; 3 algoritmos × 7 casos) README(s) verificado(s) / README(s) verified: yes (erlang/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 14/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm) -> 15/49 (…, Elm, Erlang) Observaciones / Notes: Decimoquinta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Erlang no tiene estructuras mutables (single assignment), así que los tres algoritmos son recursivos y devuelven una lista nueva: el swap in-place del pseudocódigo no es representable (divergencia idiomática aceptada). La bandera swapped se devuelve dentro de un par (bubble_pass/1 -> {Lista, Swapped}), conservando la salida temprana. rest/2 elimina la primera aparición del mínimo en lugar de una posición concreta, sin efecto observable porque ese valor es el que acaba de extraerse. Caso nulo omitido: Erlang no tiene null/nil y el tipo list() no admite entradas inválidas; una llamada con un término que no sea lista queda fuera del contrato y provoca function_clause. Ubicación desviada de la especificación: no hay run_tests.erl porque rebar3 eunit descubre automáticamente los módulos *_test.erl de test/; los nombres de archivo y la separación src/ ↔ test/ sí coinciden. La suite usa generadores de EUnit (funciones *_test_()), de modo que cada uno de los 21 tests aparece en la salida con su nombre descriptivo. El índice de fase erlang/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-15 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): forth Código verificado / Code verified: yes (mitigaciones aplicadas: (1) selection-sort usaba la palabra inexistente min_idx, que impedía cargar el módulo — se declaró variable min-idx y se reescribió el bucle interno; (2) swap-cells era over @ over @ rot ! swap !, que por el orden de ! almacenaba cada valor en su propia celda, es decir un no-op silencioso — se reescribió cruzando los dos almacenamientos con swap-tmp; (3) bubble-sort usaba j (índice externo) dentro del bucle interno, donde el índice interno es i, y la bandera swapped? se asignaba pero nunca se leía — se corrigió el índice y se añadió la salida temprana con leave) Tests y comandos / Tests and commands:

gforth -e "include src/naive_sort.forth bye" en forth/core/algorithms/naive_sort -> sin salida (exit 0, el módulo carga sin errores)
cd test && gforth run-tests.forth -> tests runned 78, passed 78, failed 0 (exit 0; 3 algoritmos × 26 aserciones) README(s) verificado(s) / README(s) verified: yes (forth/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 15/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang) -> 16/49 (…, Erlang, Forth) Observaciones / Notes: Decimosexta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Forth no tiene tipo array: una secuencia es una dirección más un número de celdas, así que el contrato es ( addr count -- ) y ordena in-place (divergencia idiomática aceptada frente al selection_sort(arr) del pseudocódigo). La especificación exige entradas de longitud variable (0, 1, 5 y 6 elementos), imposible con aridad fija. En bucles ?do anidados Forth da el índice interno en i y el externo en j, al revés de lo que sugiere el pseudocódigo. swap-cells documenta que ! es ( x addr -- ), por lo que un intercambio debe cruzar los dos almacenamientos y no puede reutilizarlos. Caso nulo omitido: no existe representación de array inválido. Ubicación desviada de la especificación: extensión .forth y naming kebab-case (naive-sort-tests.forth), siguiendo la convención de numbers/; el punto de entrada test/run-tests.forth sí existe y se añade el framework test/test.forth. El runner se extendió con set-label/append-label para que cada fallo identifique el caso con el formato "{algoritmo} should sort {caso}", verificado con una contra-verificación. El caso del array vacío se ejecuta pero no produce aserciones: con ( addr count -- ) y count 0 no hay estado observable. El índice de fase forth/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-15 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): fsharp Código verificado / Code verified: yes (el esqueleto tuvo que recrearse: dotnet new classlib y dotnet new xunit se habían ejecutado sin -lang F# y generaron proyectos de C# — Class1.cs, UnitTest1.cs, Naivesort.csproj — sin <ProjectReference>; se borraron y se recrearon con las plantillas de F#, se apuntaron los .fsproj a NaiveSort.fs y NaiveSortTests.fs y se añadió la referencia entre proyectos. La implementación pasó ambas compuertas sin mitigaciones) Tests y comandos / Tests and commands:

dotnet build NaiveSort.slnx en fsharp/core/algorithms/naive_sort -> Build succeeded. con 0 Warning(s) y 0 Error(s) (exit 0)
dotnet test NaiveSort.slnx -> Passed! - Failed: 0, Passed: 3, Skipped: 0, Total: 3, Duration: 21 ms (exit 0; 3 algoritmos × 7 casos = 21 aserciones) README(s) verificado(s) / README(s) verified: yes (fsharp/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 16/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth) -> 17/49 (…, Forth, F#) Observaciones / Notes: Decimoséptima implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. F# usa int list, que es inmutable, así que los tres algoritmos devuelven una lista nueva y el swap in-place del pseudocódigo no es representable (divergencia idiomática aceptada). La bandera swapped se devuelve dentro de un par (bubblePass -> int list * bool), conservando la salida temprana. Los helpers (pickMin, bubblePass, insert) son funciones locales, de modo que la única API son las 3 funciones del contrato — a diferencia de numbers/, donde los helpers son públicos. insert usa x <= y, lo que hace la ordenación estable. Caso nulo omitido: F# no permite el literal null para int list y no existe representación de lista inválida; el hermano de C# sí lo modela porque tiene los nullable reference types habilitados. Ubicación desviada de la especificación: src/NaiveSort.fs (PascalCase, igual que el módulo, como Numbers.fs) y test/NaiveSortTests.fs; no hay run_tests porque dotnet test descubre los tests de la solución. El layout es plano (src/{Modulo}.fsproj y test/{Modulo}.Tests.fsproj), siguiendo numbers/ en lugar del -o src/{Modulo} de la guía. El .gitignore de la raíz del submódulo cubre bin/ y obj/, con 0 artefactos rastreados. El índice de fase fsharp/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-15 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): gleam Código verificado / Code verified: yes (mitigaciones aplicadas: la primera pasada sólo tenía selection_sort, así que bubble_sort e insertion_sort faltaban y el archivo no estaba formateado; el autor los completó y el formato quedó limpio. Sin cambios míos sobre el código) Tests y comandos / Tests and commands:

gleam build en gleam/core/algorithms/naive_sort -> Compiled in 0.27s sin warnings (exit 0)
gleam format --check src test -> sin salida (exit 0); es el comando que ejecuta el CI del propio scaffold
gleam test -> 3 passed, no failures (exit 0; 3 algoritmos × 7 casos = 21 aserciones) README(s) verificado(s) / README(s) verified: yes (gleam/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 17/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#) -> 18/49 (…, F#, Gleam) Observaciones / Notes: Decimoctava implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Gleam no tiene bucles ni mutabilidad, así que los tres algoritmos son recursivos y devuelven una lista nueva: el swap in-place del pseudocódigo no es representable (divergencia idiomática aceptada). La bandera swapped se pasa como parámetro a bubble_pass y se devuelve dentro de un par #(List(Int), Bool), conservando la salida temprana. Los helpers (pick_min, bubble_pass, insert) son privados (fn sin pub), de modo que la única API son las 3 funciones del contrato. insert usa x <= y, lo que hace la ordenación estable. pick_min devuelve el resto en el orden en que lo acumuló, sin efecto observable porque se vuelve a ordenar. Caso nulo omitido: Gleam no tiene null/nil ni representación de lista inválida. Ubicación: src/naive_sort.gleam y test/naive_sort_test.gleam coinciden con el naming esperado; no hay run_tests porque el entry point de gleeunit es una función main dentro del propio módulo de pruebas, y gleam test además exige que ese módulo se llame <name>_test según el campo name de gleam.toml. Se eliminó la función main de ejemplo que genera gleam new en src/, igual que en numbers/. El índice de fase gleam/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-15 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): go Código verificado / Code verified: yes (el esqueleto se entregó sin implementación — sólo package src y la cabecera del contrato — y go test ./... fallaba con imported and not used y undefined: SelectionSort/BubbleSort/InsertionSort; el autor añadió las tres funciones y ambas compuertas pasaron sin mitigaciones. Sin cambios míos sobre el código) Tests y comandos / Tests and commands:

go vet ./... en go/core/algorithms/naive_sort -> sin salida (exit 0)
gofmt -l . -> sin salida (exit 0)
go build ./... -> sin salida (exit 0)
go test ./... -v -count=1 -> --- PASS: TestSelectionSort, --- PASS: TestBubbleSort, --- PASS: TestInsertionSort, PASS, ok example.com/naive_sort/tests 0.003s (exit 0; 3 algoritmos × (7 casos + caso nulo) = 24 aserciones)
Contra-verificación en copia desechable (/tmp, ya eliminada): cambiando arr[j] < arr[minIdx] por > en selection_sort -> --- FAIL: TestSelectionSort con Messages: selection_sort should sort an unsorted array (y los demás casos afectados), exit 1; revertido -> ok README(s) verificado(s) / README(s) verified: yes (go/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 18/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam) -> 19/49 (…, Gleam, Go) Observaciones / Notes: Decimonovena implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Go sí puede representar el caso nulo y ordenar in-place, así que los tres algoritmos mutan el slice recibido y lo devuelven, y el indicador de fallo es el slice nil: la guarda len(arr) <= 1 devuelve el propio slice sin tocarlo, de modo que nil entra y nil sale sin comprobación especial ni panic. Es el segundo hermano de la fase, tras C# con int[]?, que cubre el caso nulo de forma explícita; el caso nulo se prueba por separado del caso vacío porque nil y []int{} son valores distintos en Go. Como los fixtures de la suite son variables compartidas a nivel de paquete y los algoritmos mutan in-place, cada caso ordena una copia creada con copyInput (make + copy). La bandera swapped se conserva usando for swapped como condición del bucle externo, equivalente al swapped + break del pseudocódigo sin contar pasadas con un índice externo; selection_sort intercambia sin la guarda if min_idx != i del pseudocódigo, sin efecto observable porque un auto-intercambio es un no-op. Naming exportado en PascalCase (SelectionSort, BubbleSort, InsertionSort), obligatorio porque los tests viven en el paquete tests separado del paquete src. Ubicación desviada de la especificación: el directorio de pruebas es tests/ en plural (siguiendo numbers/) y no existe run_tests porque go test ./... descubre automáticamente las funciones TestXxx; la extensión .go y el nombre naive_sort.go sí coinciden. .gitignore: no se añade uno de módulo porque el de la raíz de go/ ya cubre los artefactos, verificado con git check-ignore -v tests/tests.test -> .gitignore:12:*.test, con 0 artefactos rastreados. La versión de testify se fijó a v1.11.1 para que go.mod coincida exactamente con el de numbers/ (go mod tidy había resuelto v1.12.1). El índice de fase go/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-15 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): grain Código verificado / Code verified: yes (tres pasadas. Las dos primeras no compilaban: faltaba => en las ocho definiciones de función, los match no llevaban paréntesis, los brazos usaban | inicial y comas omitidas, el patrón x::xs no existe en Grain, not swapped no es operador y List.get/List.set no existen en la biblioteca estándar; además los nombres exportados eran selectionsort/bubblesort/insertionsort. Con autorización del autor se reescribió el módulo: sintaxis válida de Grain 0.7.2, naming camelCase, pickMin/removeFirst/bubblePass/insert anidados con let rec dentro de su función padre como en numbers/, y sin ninguna llamada a biblioteca — se eliminó el List.reduce que usaba insertionSort y el from "list" include List, de modo que el módulo sólo usa literales [...], pattern matching [x, ...xs], comparaciones y recursión) Tests y comandos / Tests and commands:

make build en grain/core/algorithms/naive_sort -> sin salida (exit 0, sin warnings)
make test -> grain compile tests/run_tests.gr + grain run tests/run_tests.wasm, --- Test Summary ---, Tests: 21 passed, 0 failed, 21 total (exit 0; 3 algoritmos × 7 casos)
grep -n "List\.\|include\|import" src/naive_sort.gr -> sin coincidencias (0 llamadas a biblioteca en la implementación)
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo x < minValue por x > minValue en el pickMin de selectionSort -> FAILED: selection_sort should sort an unsorted array — expected [1, 2, 5, 5, 6, 9], got [9, 6, 5, 5, 2, 1] y otros 3 casos, Tests: 17 passed, 4 failed, 21 total; revertido -> 21 passed, 0 failed README(s) verificado(s) / README(s) verified: yes (grain/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 19/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go) -> 20/49 (…, Go, Grain) Observaciones / Notes: Vigésima implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. El literal [1, 2, 3] de Grain construye una List<Number>, que es inmutable — Array es el tipo mutable, pero ni el literal idiomático ni numbers/ lo usan —, así que los tres algoritmos son recursivos y devuelven una lista nueva: el swap in-place del pseudocódigo no es representable (divergencia idiomática aceptada). La bandera swapped se devuelve dentro de un par (List<Number>, Bool), conservando la salida temprana: una lista ya ordenada se resuelve en una sola pasada. insert usa x <= y, lo que hace la ordenación estable. removeFirst elimina la primera aparición del mínimo, sin efecto observable aunque el mínimo se repita (caso [7, 7, 7, 7]). Caso nulo omitido: Grain no tiene null/nil ni listas inválidas, igual que F# y Gleam. La implementación no importa ningún módulo de la biblioteca estándar y no hace ninguna llamada List.*, en línea con el criterio de aceptación de la especificación; los helpers van anidados con let rec dentro de la función padre, por lo que son privados a ese ámbito y la única API pública son las 3 funciones del contrato (insertionSort no lleva rec porque la recursión vive en su helper loop, igual que el enfoque con acumulador de numbers/). Ubicación desviada de la especificación: el directorio de pruebas es tests/ en plural (siguiendo numbers/) y la extensión es .gr; el punto de entrada tests/run_tests.gr sí existe y se le añade tests/testing.gr, el mini framework reutilizado literalmente de numbers/ (md5 b50574efd745fbc03c47c3c30ded2312). .gitignore propio con target/, *.gro, *.wasm y *.wasm.map: los dos últimos no estaban cubiertos en numbers/ (donde tests/run_tests.wasm queda como artefacto no ignorado), verificado con git check-ignore -v sobre los 5 artefactos y con 0 artefactos rastreados. El índice de fase grain/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-16 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): groovy Código verificado / Code verified: yes (sin mitigaciones. ./gradlew compileGroovy compileTestGroovy compila src/main y src/test sin ningún diagnóstico; los 4 avisos Deprecated Gradle features que emite Gradle provienen del bloque testlogger de lib/build.gradle:53-57 —sintaxis de asignación con espacio, retirada en Gradle 10— y son idénticos, línea por línea, en el bloque homólogo de foundations/numbers, así que se documentan en el README como aviso heredado del scaffold y no como defecto del código) Tests y comandos / Tests and commands:

./gradlew clean test --rerun-tasks --console=plain en groovy/core/algorithms/naive_sort -> > Task :lib:test, org.example.NaiveSortTest, Test selection_sort should sort all cases PASSED, Test bubble_sort should sort all cases PASSED, Test insertion_sort should sort all cases PASSED, SUCCESS: Executed 3 tests in 655ms, BUILD SUCCESSFUL in 2s (exit 0; 3 tests × (7 casos + caso nulo) = 24 aserciones)
git check-ignore -v sobre .gradle/8.14.3/gc.properties, lib/build/.../NaiveSort.class, build/reports/.../index.html y lib/bin/.../NaiveSort.groovy -> cubiertos por .gitignore:2:.gradle, .gitignore:5:build y .gitignore:11:bin; 0 artefactos rastreados en el módulo
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo arr[j] > key por arr[j] < key en el bucle interno de insertionSort -> Test insertion_sort should sort all cases FAILED, insertion_sort should sort an unsorted array, FAILURE: Executed 3 tests in 937ms (1 failed); revertido -> SUCCESS: Executed 3 tests README(s) verificado(s) / README(s) verified: yes (groovy/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 20/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain) -> 21/49 (…, Grain, Groovy) Observaciones / Notes: Vigesimoprimera implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. El scaffold se generó con gradle init --type groovy-library, que produce un proyecto Gradle multiproyecto con submódulo lib; se eliminaron los placeholders Library.groovy y LibraryTest.groovy y se añadió a lib/build.gradle el plugin com.adarshr.test-logger 4.0.0 con su bloque testlogger, para que la salida muestre cada test por nombre igual que en numbers/. La especificación admite ordenar in-place o devolver una copia: las tres funciones hacen list.clone() y ordenan la copia, de modo que la lista del llamador nunca se muta mientras la mutación interna sigue siendo la del pseudocódigo. Groovy admite null en List<Integer>, así que el caso nulo sí es representable y se cubre de forma explícita: if (list == null) return null, sin lanzar excepciones, y separado del caso vacío porque null y [] son valores distintos. La bandera swapped se implementa con do { ... } while (swapped), equivalente al swapped + break del pseudocódigo, conservando el mejor caso $O(n)$; el bucle interno no se acorta con el contador de pasadas (for j = 0 to n - 2 - i), lo que no altera el comportamiento observable ni la complejidad prometida y queda documentado en el README. insertionSort desplaza con arr[j] > key estricto, lo que la hace estable. Naming camelCase (NaiveSort.selectionSort(list)), coherente con Numbers.sumFirstNRec(n); los tres cuerpos son autocontenidos, con los bucles internos inline. Ubicación desviada de la especificación: el layout es lib/src/main/groovy/org/example/ y lib/src/test/groovy/org/example/ (árbol estándar de Gradle y paquete org.example, igual que numbers/) y no existe run_tests porque ./gradlew test descubre las clases Specification de Spock. El .gitignore añade bin a las entradas generadas (.gradle, build, .kotlin) para cubrir las clases que algunos IDE compilan fuera de build/, verificado con git check-ignore -v. El índice de fase groovy/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-16 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): haskell Código verificado / Code verified: yes (mitigación aplicada con autorización: cabal build all con -Wall reportaba lib/NaiveSort.hs:44:24: warning: [GHC-40910] [-Wunused-local-binds] Defined but not used: 'swapped' — en la rama x > y de bubblePass se ligaba la bandera de la llamada recursiva y se descartaba, porque esa rama devuelve True incondicionalmente; se cambió let (swapped, rest) por let (_, rest). Tras la mitigación lib/ y test/ compilan sin ningún warning con -Wall) Tests y comandos / Tests and commands:

cabal build all --enable-tests en haskell/core/algorithms/naive_sort -> compila la librería ([1 of 1] Compiling NaiveSort), el spec ([1 of 2] Compiling NaiveSortSpec) y el runner ([2 of 2] Compiling Main) sin ningún warning (exit 0)
cabal test --test-show-details=direct -> 21 ejemplos con nombre "{algoritmo} should sort {caso}", Finished in 0.0008 seconds, 21 examples, 0 failures, Test suite naive-sort-test: PASS, 1 of 1 test suites (1 of 1 test cases) passed. (exit 0; 3 algoritmos × 7 casos)
git check-ignore -v dist-newstyle/build/.../NaiveSort.o -> .gitignore:2:dist-* (el .gitignore de la raíz de haskell/ ya cubre los artefactos; no se añade uno de módulo, igual que en numbers/), con 0 artefactos rastreados
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo x > y por x < y en bubblePass -> bubble_sort should sort an unsorted array [✘], bubble_sort should sort an already sorted array [✘], bubble_sort should sort a reverse ordered array [✘] y bubble_sort should sort an array with negative numbers [✘] (los casos de un elemento, idénticos y vacío siguen pasando, como es de esperar); revertido -> 21 examples, 0 failures README(s) verificado(s) / README(s) verified: yes (haskell/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 21/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy) -> 22/49 (…, Groovy, Haskell) Observaciones / Notes: Vigesimosegunda implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. El scaffold se generó con cabal init --lib; se eliminó el placeholder MyLib.hs y el manifiesto se alineó con numbers.cabal: exposed-modules: NaiveSort, other-modules: NaiveSortSpec y hspec ^>=2.11.0 en build-depends del test-suite. [Int] es inmutable, así que los tres algoritmos devuelven una lista nueva: el swap in-place del pseudocódigo no es representable (divergencia idiomática aceptada). Caso nulo omitido: Haskell no tiene null ni listas inválidas, igual que F# y Gleam. La bandera swapped viaja en un par (Bool, [Int]) devuelto por bubblePass, conservando la salida temprana; la rama x > y descarta la bandera de la recursión porque devuelve True incondicionalmente; esa ligadura sin usar era el único warning de -Wall y quedó mitigada. bubblePass no acorta la pasada con el contador externo del pseudocódigo (0 to n-2-i), sin cambio observable ni de complejidad. insertionSort ordena la cola y luego inserta la cabeza (insert x (insertionSort xs)) en lugar de acumular un prefijo ordenado de izquierda a derecha, y insert usa x <= y, lo que hace la ordenación estable. pickMin :: [Int] -> (Int, [Int]) fusiona en una sola pasada la búsqueda del mínimo y su extracción del resto, así que selectionSort no necesita un segundo recorrido; su guarda error es inalcanzable desde la API exportada porque selectionSort resuelve antes [] y [x], de modo que ninguna función del contrato lanza excepciones. El módulo exporta sólo las 3 funciones del contrato; pickMin, bubblePass e insert son privados. Ubicación desviada de la especificación: lib/NaiveSort.hs (PascalCase, igual que Numbers.hs), test/NaiveSortSpec.hs (sufijo Spec, como RecursiveSpec.hs) y test/RunTests.hs, que sí existe como punto de entrada declarado en main-is. El índice de fase haskell/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): haxe Código verificado / Code verified: yes (sin mitigaciones. haxe build.hxml compila src/ y test/ sin ningún diagnóstico; el build.hxml sólo desactiva un aviso interno de la propia librería utest con -w -WDeprecatedEnumAbstract, como en numbers/) Tests y comandos / Tests and commands:

haxe build.hxml en haxe/core/algorithms/naive_sort -> assertations: 123, successes: 123, errors: 0, failures: 0, warnings: 0, results: ALL TESTS OK (success: true), test.NaiveSortTest con testBubbleSort: OK, testInsertionSort: OK, testSelectionSort: OK (exit 0; 3 funciones × 8 casos —7 de la especificación + el nulo—, 123 aserciones por el desglose de assertArrayEquals en longitud + elemento)
cat -A .gitignore -> .haxelib/, .haxelsp/recording/, dump/ y bin/; --interp no genera artefactos, así que no hay nada que destrackear (0 artefactos rastreados en el módulo)
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo arr[j] < arr[minIndex] por arr[j] > arr[minIndex] en selectionSort -> failures: 16 frente a successes: 107, con mensajes line: 40, selection_sort should sort an unsorted array (mismatch at index 0), … (mismatch at index 1), y los mismos para an already sorted array; revertido -> 123 successes, 0 failures README(s) verificado(s) / README(s) verified: yes (haxe/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 22/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell) -> 23/49 (…, Haskell, Haxe) Observaciones / Notes: Vigesimotercera implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Haxe permite reproducir el pseudocódigo casi literalmente: Array<Int> es mutable y se pasa por referencia, así que los tres algoritmos ordenan in-place el array recibido y lo devuelven, y las cotas de los bucles se copian tal cual (0...n - 1, i + 1...n y 0...n - i - 1, cuyos rangos excluyen el límite superior). La bandera swapped se implementa con if (!swapped) break;, igual que el pseudocódigo. insertionSort desplaza con arr[j] > key estricto, lo que la hace estable. Array<Int> admite null, así que el caso nulo sí es representable y se cubre de forma explícita con if (arr == null) return null;, sin lanzar excepciones y separado del caso vacío porque null y [] son valores distintos. Como los fixtures de la suite son constantes compartidas a nivel de clase y los algoritmos mutan in-place, cada caso ordena una copia creada con .copy(). Naming camelCase (NaiveSort.selectionSort(arr)), coherente con Numbers.sumOfFirstNRec(n); los tres cuerpos son autocontenidos, con los bucles inline. Ubicación desviada de la especificación: src/NaiveSort.hx y test/NaiveSortTest.hx (Haxe exige que el archivo se llame como la clase), y el punto de entrada RunTests.hx vive en la raíz del módulo, no en test/, porque -cp . cubre el directorio y así lo hace numbers/. El índice de fase haxe/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): java Código verificado / Code verified: yes (sin mitigaciones sobre el código. El scaffold del archetype tuvo que reestructurarse: mvn archetype:generate con maven-archetype-quickstart:1.4 generó layout anidado naive_sort/naive_sort/, groupId com.example, Java 1.7, JUnit 4.11, paquete com.example y un App.java con main; se aplanó el layout, se reescribió pom.xml como el de numbers/ y se eliminó el placeholder. Sobre el pom.xml se aplicó una segunda corrección autorizada: maven.compiler.source/target = 17 emitía [WARNING] location of system modules is not set in conjunction with -source 17 bajo el JDK 25 del entorno, así que se sustituyó por <maven.compiler.release>25</maven.compiler.release>, que fija source, target y la plataforma de APIs y elimina el aviso) Tests y comandos / Tests and commands:

mvn clean test-compile en java/core/algorithms/naive_sort -> [INFO] Building naive_sort 1.0.0, [INFO] BUILD SUCCESS, sin ningún warning (exit 0)
mvn test -> [INFO] Running naive_sort.NaiveSortTest, [INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.039 s -- in naive_sort.NaiveSortTest, [INFO] BUILD SUCCESS (exit 0; 3 algoritmos × 8 casos —7 de la especificación + el nulo— = 24 aserciones)
git check-ignore -v target/classes/naive_sort/NaiveSort.class -> core/algorithms/naive_sort/.gitignore:1:target/ target/classes/naive_sort/NaiveSort.class, con 0 artefactos rastreados
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo arr[j] > arr[j + 1] por arr[j] < arr[j + 1] en bubbleSort -> naive_sort.NaiveSortTest.testBubbleSort -- Time elapsed: 0.006 s <<< FAILURE!, org.opentest4j.AssertionFailedError: bubble_sort should sort an unsorted array ==> array contents differ at index [0], expected: <1> but was: <9>, Failures: 1; revertido -> Tests run: 3, Failures: 0 README(s) verificado(s) / README(s) verified: yes (java/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 23/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe) -> 24/49 (…, Haxe, Java) Observaciones / Notes: Vigesimocuarta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Java permite reproducir el pseudocódigo casi literalmente: int[] es mutable y se pasa por referencia, así que los tres algoritmos ordenan in-place el array recibido y lo devuelven, y las cotas de los bucles se copian tal cual (i < n - 1, j = i + 1, j < n - i - 1). La bandera swapped se implementa con if (!swapped) break;, igual que el pseudocódigo. insertionSort desplaza con arr[j] > key estricto, lo que la hace estable. int[] admite null, así que el caso nulo sí es representable y se cubre de forma explícita con if (arr == null) return null;, sin lanzar excepciones y separado del caso vacío porque null y new int[0] son valores distintos. Como los fixtures de la suite son constantes static final y los arrays de Java son mutables, cada caso ordena una copia creada con .clone(). Naming camelCase (NaiveSort.selectionSort(arr)), coherente con Numbers.sumOfFirstNRec(n); los tres cuerpos son autocontenidos, con los bucles inline. Ubicación desviada de la especificación: layout estándar de Maven (src/main/java/naive_sort/NaiveSort.java y src/test/java/naive_sort/NaiveSortTest.java), con el paquete igual al nombre del módulo como en numbers/, y sin run_tests porque mvn test descubre los métodos @Test con surefire. Nivel de Java: los tres módulos del submódulo (naive_sort, numbers y calculator) declaran <maven.compiler.release>25</maven.compiler.release> porque el JDK por defecto del entorno es el 25.0.4; numbers/ y calculator/ se alinearon en el mismo cambio (ver la entrada core.foundations.numbers + core.foundations.unit_test de esta misma fecha). El índice de fase java/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core Módulo(s) / Module(s): core.foundations.numbers + core.foundations.unit_test Lenguaje(s) / Language(s): java Código verificado / Code verified: yes (cambio de toolchain, sin tocar código ni pruebas: maven.compiler.source/target = 17 sustituido por <maven.compiler.release>25</maven.compiler.release> en los dos pom.xml, alineándolos con core/algorithms/naive_sort. Motivo: bajo el JDK 25.0.4 del entorno, -source 17 -target 17 hacía que javac no encontrara los módulos del sistema y emitiera [WARNING] location of system modules is not set in conjunction with -source 17; release fija source, target y la plataforma de APIs a la vez y elimina el aviso. Efecto: los tres módulos de Java requieren ahora JDK 25 para compilarse; el código no usa características posteriores a Java 8) Tests y comandos / Tests and commands:

mvn clean test en java/core/foundations/numbers -> [INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0 ... in numbers.NumbersRecursiveTest, [INFO] Tests run: 5 ... in numbers.NumbersIterativeTest, [INFO] Tests run: 10, Failures: 0, Errors: 0, Skipped: 0, [INFO] BUILD SUCCESS, sin ningún warning (exit 0)
mvn clean test en java/core/foundations/unit_test/calculator -> [INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0 ... in calculator.CalculatorTest, [INFO] BUILD SUCCESS, sin ningún warning (exit 0) README(s) verificado(s) / README(s) verified: yes (java/README.md, java/core/foundations/README.md, java/core/foundations/numbers/README.md, java/core/foundations/unit_test/calculator/README.md, java/core/algorithms/README.md y java/core/algorithms/naive_sort/README.md — todas las menciones a JDK 17 y al nivel de lenguaje actualizadas) Cambio en ROADMAP.md / ROADMAP.md change: ninguno (los contadores X/49 no cambian: no se cierra ningún módulo, solo se actualiza el toolchain de módulos ya cerrados) Observaciones / Notes: Cambio transversal de toolchain en los módulos de Java ya homologados, para que los tres compartan el mismo nivel declarado y ninguno emita avisos al compilarse bajo el JDK por defecto (25.0.4). Se actualizaron también las cinco menciones a «JDK 17» / «Java 17» repartidas entre el README del submódulo, el de la fase de fundamentos y los de numbers y calculator, y las dos notas de algorithms que describían la discrepancia anterior. Si en el futuro se quiere recuperar la portabilidad a JDK 17, basta con cambiar 25 por 17 en los tres pom.xml: release 17 también elimina el aviso, porque el problema era usar source/target en lugar de release, no el número de versión.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): javascript Código verificado / Code verified: yes (sin mitigaciones. El scaffold de npm init generó un package.json mínimo en javascript/algorithms/naive_sort — sin el segmento core/ — así que el directorio se movió a javascript/core/algorithms/naive_sort y el manifiesto se reescribió con la forma del de numbers/: main, script test y jest ^30.0.5 en devDependencies) Tests y comandos / Tests and commands:

node --check src/naive_sort.js, node --check test/naive_sort.test.js y node --check jest.config.js -> sin salida (exit 0); es la verificación estática disponible, ya que JavaScript no tiene compilador y el módulo no configura linter, igual que numbers/
npm test -> Test Suites: 1 passed, 1 total, Tests: 3 passed, 3 total, Time: 0.208 s (exit 0; 3 algoritmos × 8 casos —7 de la especificación + el nulo— = 24 aserciones)
npm install -> added 278 packages, and audited 279 packages in 9s, found 0 vulnerabilities; genera package-lock.json, que se versiona como en numbers/ y calculator/
git check-ignore -v node_modules/jest/package.json -> core/algorithms/naive_sort/.gitignore:1:node_modules/, con 0 artefactos rastreados
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo arr[j] < arr[minIndex] por arr[j] > arr[minIndex] en selectionSort -> ● selection_sort, selection_sort should sort an unsorted array, expected: [1, 2, 5, 5, 6, 9], received: [9, 6, 5, 5, 2, 1], Tests: 1 failed, 2 passed, 3 total; revertido -> 3 passed, 3 total README(s) verificado(s) / README(s) verified: yes (javascript/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 24/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java) -> 25/49 (…, Java, JavaScript) Observaciones / Notes: Vigesimoquinta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. JavaScript permite reproducir el pseudocódigo casi literalmente: los arrays son mutables y se pasan por referencia, así que los tres algoritmos ordenan in-place el array recibido y lo devuelven, y las cotas de los bucles se copian tal cual (i < n - 1, j = i + 1, j < n - i - 1). El intercambio usa asignación por destructuring ([arr[i], arr[minIndex]] = [arr[minIndex], arr[i]]), sin variable temporal. La bandera swapped se implementa con if (!swapped) break;, igual que el pseudocódigo. insertionSort desplaza con arr[j] > key estricto, lo que la hace estable. El indicador de fallo usa arr == null (comparación no estricta deliberada), que cubre a la vez null y undefined; el caso nulo se prueba explícitamente y por separado del vacío, porque null y [] son valores distintos. Como los fixtures de la suite son constantes de módulo y los arrays de JavaScript son mutables, cada caso ordena una copia creada con [...input]. Naming camelCase, coherente con numbers/; las funciones se declaran con function (en numbers/ son const f = () => {}) para poder colocar el module.exports al principio gracias al hoisting, y el módulo exporta sólo las 3 funciones del contrato. La suite registra un matcher propio con expect.extend (toBeSortedAs) para poder adjuntar el mensaje "{algoritmo} should sort {caso}" al fallo, ya que Jest no acepta un mensaje como argumento de expect(); el helper compartido sigue siendo único. Ubicación desviada de la especificación: src/naive_sort.js y test/naive_sort.test.js (la convención de Jest del repositorio es el sufijo *.test.js, como numbers.rec.test.js), y no existe run_tests porque npm test ejecuta jest, que descubre los archivos por testMatch. El índice de fase javascript/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): julia Código verificado / Code verified: yes (sin mitigaciones. El módulo no existía, así que se creó con la estructura manual que marca la guía —mkdir -p src test + Project.toml— siguiendo la convención de numbers/: Project.toml con nombre, UUID propio, [compat] julia = "1.10" y el target de test, src/NaiveSort.jl con module + export, y el punto de entrada test/run_tests.jl) Tests y comandos / Tests and commands:

julia --project=. -e 'include("src/NaiveSort.jl")' -> sin salida (exit 0); es la verificación estática disponible, ya que Julia no tiene compilador con avisos y el módulo no configura linter, igual que numbers/
julia --project=. test/run_tests.jl -> Test Summary: | Pass Total Time, Naive Sort Tests | 24 24 0.5s (exit 0; 3 algoritmos × 8 casos —7 de la especificación + el nulo— = 24 aserciones)
git check-ignore -v core/algorithms/naive_sort/Manifest.toml -> .gitignore:24:Manifest*.toml; el módulo no necesita .gitignore propio porque el de la raíz de julia/ ya cubre los artefactos (Manifest*.toml, *.jl.cov, *.jl.mem, LocalPreferences.toml), con 0 artefactos rastreados
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo arr[j] < arr[min_index] por arr[j] > arr[min_index] en selection_sort -> selection_sort should sort an unsorted array: Test Failed at .../naive_sort_tests.jl:53, y los mismos para an already sorted array, a reverse ordered array y an array with negative numbers, con 20 passed, 4 failed, 0 errored; revertido -> 24 passed README(s) verificado(s) / README(s) verified: yes (julia/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 25/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript) -> 26/49 (…, JavaScript, Julia) Observaciones / Notes: Vigesimosexta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Julia usa snake_case para las funciones, que es justo la convención de la especificación, así que la API es selection_sort, bubble_sort e insertion_sort sin traducir los nombres. La única divergencia estructural respecto al pseudocódigo es la indexación basada en 1, impuesta por el lenguaje: j = i + 1 to n - 1 pasa a for j in i+1:n, j = 0 to n - 2 - i pasa a for j in 1:n-i y la inserción desplaza desde i = 2 con j >= 1, con el mismo número de iteraciones y el mismo orden de comparaciones. Vector es mutable y se pasa por referencia, así que los tres algoritmos ordenan in-place el vector recibido y lo devuelven, con intercambio por asignación múltiple (arr[i], arr[min_index] = arr[min_index], arr[i]). La bandera swapped se implementa con if !swapped break end, igual que el pseudocódigo. insertion_sort desplaza con arr[j] > key estricto, lo que la hace estable. Julia no tiene null: su valor de «ningún valor» es nothing (singleton de Nothing), así que el caso nulo es representable y se cubre con if arr === nothing return nothing end, comparación de identidad idiomática contra un singleton, separado del caso vacío porque nothing y Int[] son valores distintos. Los parámetros van sin anotación de tipo, como en numbers/, lo que permite aceptar nothing. Como los fixtures de la suite son constantes de módulo y los vectores de Julia son mutables, cada caso ordena una copia creada con copy(input). La descripción de cada caso va en el nombre del @testset que genera el helper ("$algorithm should sort $description"), porque @test no admite mensaje adjunto; run_tests.jl conserva el nombre exacto que espera la especificación y que Pkg.test() busca por convención. Ubicación desviada de la especificación: src/NaiveSort.jl (PascalCase, igual que el módulo, como Numbers.jl) y test/naive_sort_tests.jl (sufijo _tests.jl, como recursive_tests.jl). El índice de fase julia/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): kotlin Código verificado / Code verified: yes (sin mitigaciones; gradle compileKotlin compileTestKotlin no emite ninguna línea w: ni e:) Tests y comandos / Tests and commands:

gradle compileKotlin compileTestKotlin --console=plain -> BUILD SUCCESSFUL in 1s (exit 0, sin avisos del compilador de Kotlin)
gradle test --console=plain -> > Task :test y BUILD SUCCESSFUL in 1s (exit 0); el reporte build/test-results/test/TEST-naive_sort.NaiveSortTest.xml da tests="3" skipped="0" failures="0" errors="0" con los testcase selection_sort, bubble_sort e insertion_sort (3 algoritmos × 8 casos —7 de la especificación + el nulo— = 24 comprobaciones)
git check-ignore -v core/algorithms/naive_sort/build/classes -> .gitignore:3:build/; .gradle/ y .kotlin/ por las líneas 2 y 7; los cuatro patrones generados (.gradle/, build/, bin/, .kotlin/) son idénticos a los de numbers/ y calculator/, y con 6 archivos rastreados en el módulo no hay ningún artefacto versionado
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo arr[j] < arr[minIndex] por arr[j] > arr[minIndex] en selectionSort -> NaiveSortTest > selection_sort FAILED y BUILD FAILED in 2s (exit 1), con org.opentest4j.AssertionFailedError: selection_sort should sort an unsorted array / Element differ at index: [0, 1, 4, 5] / expected:<[1, 2, 5, 5, 6, 9]> but was:<[9, 6, 5, 5, 2, 1]>; revertido -> verde README(s) verificado(s) / README(s) verified: yes (kotlin/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 26/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia) -> 27/49 (…, Julia, Kotlin) Observaciones / Notes: Vigesimoséptima implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Kotlin usa camelCase para las funciones (selectionSort, bubbleSort, insertionSort), que es su convención, mientras que la especificación las nombra en snake_case; el nombre de la especificación se conserva como nombre del test, de modo que el reporte de Gradle y los testcase del XML siguen mostrando selection_sort, bubble_sort e insertion_sort. Las tres funciones se exponen como miembros de un object (NaiveSort), igual que Numbers.kt en numbers/, y comparten la firma (IntArray?): IntArray?, lo que permite que el helper de test las reciba como referencia de función sin envolverlas en lambdas. IntArray es mutable y se pasa por referencia en la JVM, así que los tres algoritmos ordenan in-place el array recibido y devuelven ese mismo array; los casos se aíslan copiando la entrada con case.input?.copyOf() porque los fixtures son constantes compartidas. Kotlin no necesita mecanismos artificiales para el indicador de fallo: IntArray? admite null, así que if (arr == null) return null es la comprobación idiomática, y el caso nulo, que es representable, se prueba de forma independiente del caso vacío ([]). Las cotas de los bucles reproducen literalmente las del pseudocódigo mediante rangos semiabiertos (0 until n - 1, i + 1 until n, 0 until n - i - 1), que ya excluyen el extremo superior, sin desplazamientos manuales con -1/+1 que justificar. La bandera swapped se implementa con if (!swapped) break, como exige la especificación, lo que deja el mejor caso en O(n); insertionSort desplaza con la comparación estricta arr[j] > key, lo que la hace estable. En los tests, el mensaje del contrato se antepone con withClue("$algorithm should sort ${case.description}"), y la comparación usa .toList() porque IntArray no sobrescribe equals y comparar arrays directamente compararía referencias. El proyecto se generó con gradle init y se reestructuró para alinearlo con numbers/: se aplanó el layout multi-proyecto (lib/ y gradle/libs.versions.toml), se sustituyó JUnit por Kotest 6.2.4 (kotest-runner-junit5 + kotest-assertions-core), el paquete org.example pasó a naive_sort y se eliminaron el wrapper (gradlew, gradlew.bat, gradle/wrapper/) y el catálogo de versiones, porque ni numbers/ ni calculator/ los incluyen; el plugin kotlin("jvm") version "2.4.10" va versionado en línea. Ubicación desviada de la especificación: src/main/kotlin/naive_sort/NaiveSort.kt (layout estándar de Gradle, archivo en PascalCase como Numbers.kt) y src/test/kotlin/naive_sort/NaiveSortTest.kt (sufijo Test, como NumbersIterativeTest.kt), sin equivalente a test/run_tests.ext porque Gradle descubre y ejecuta la suite a través de JUnit Platform. El índice de fase kotlin/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): lua Código verificado / Code verified: yes (sin mitigaciones; luac -p válido en ambos archivos y la carga con lua -W no emite avisos) Tests y comandos / Tests and commands:

luac -p src/naive_sort.lua y luac -p test/naive_sort_tests.lua -> sin salida y exit 0 en ambos; la distribución estándar de Lua no trae analizador estático, así que la verificación estática es el modo «solo analizar» del compilador
lua -W -e 'require("naive_sort")' -> function function function (las tres funciones existen y la carga no emite warnings)
busted -> ●●● y 3 successes / 0 failures / 0 errors / 0 pending : 0.000791 seconds (exit 0; 3 tests, uno por algoritmo, con los 8 casos como aserciones dentro de cada uno = 24 comprobaciones)
luarocks test naive_sort-1.0.0-1.rockspec -> 3 successes / 0 failures / 0 errors, con naive_sort 1.0.0-1 depends on busted (2.3.0-1 installed: success)
luarocks make naive_sort-1.0.0-1.rockspec -> naive_sort 1.0.0-1 is now installed in /home/yorche3/.luarocks (license: MIT), tras lo cual require("naive_sort") resuelve el módulo
git check-ignore -v lua_modules/lib/x luarocks lua .luarocks/config-5.5.lua naive_sort-1.0.0-1.src.rock luac.out -> el .gitignore del módulo cubre los artefactos del proyecto de LuaRocks (/luarocks, /lua, /lua_modules, /.luarocks) y el de la raíz de lua/ cubre *.src.rock y *.out; ninguno de esos directorios existía tras ejecutar los comandos precedentes
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo arr[j] < arr[min_index] por arr[j] > arr[min_index] en selection_sort -> 2 successes / 1 failure / 0 errors / 0 pending, con test/naive_sort_tests.lua:65: selection_sort should sort an unsorted array y el array {9, 6, 5, 5, 2, 1} frente al esperado {1, 2, 5, 5, 6, 9}; revertido -> verde README(s) verificado(s) / README(s) verified: yes (lua/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 27/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin) -> 28/49 (…, Julia, Kotlin, Lua) Observaciones / Notes: Vigesimoctava implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. El proyecto se inició con luarocks init, que genera un rockspec genérico (naive_sort-dev-1.rockspec, con source apuntando a un repositorio propio y modules = {}), los envoltorios lua/luarocks y los directorios .luarocks/ y lua_modules/; se reestructuró a la convención de numbers/ (rockspec escrito a mano con rockspec_format = "3.0", build.type = "builtin" y test_dependencies = { "busted" }, más .busted con ROOT = { "test" } y pattern = { "_test", "_spec" }), y se eliminaron el rockspec genérico, los envoltorios y ambos directorios. La guía de inicialización recomienda luarocks init para Lua, pero el módulo ya homologado gana como fuente de verdad. El árbol del sistema (/usr/local/lib/luarocks/rocks-5.5) es de root, así que el autor activó luarocks config local_by_default true y a partir de ahora --local es implícito en el árbol de usuario ~/.luarocks. Las funciones usan snake_case (selection_sort), que coincide con el nombre de la especificación, así que la API no necesita traducción. La única divergencia estructural es la indexación basada en 1: for i = 0 to n - 2 pasa a for i = 1, n - 1, for j = i + 1 to n - 1 a for j = i + 1, n, la pasada interna de bubble a for j = 1, n - i y la inserción a for i = 2, n con while j >= 1, con el mismo número de iteraciones y el mismo orden de comparaciones. Las tablas de Lua son mutables y se pasan por referencia, de modo que los tres algoritmos ordenan in-place la tabla recibida y devuelven esa misma tabla, con intercambio por asignación múltiple (arr[i], arr[min_index] = arr[min_index], arr[i]). nil es un valor de primera clase en Lua y actúa como indicador de fallo mediante if arr == nil then return nil end, sin lanzar errores; el caso nulo se prueba aparte del caso vacío porque nil y {} son valores distintos. Los tests comparan con assert.same porque == sobre tablas compara referencias, y el mensaje del contrato se pasa como tercer argumento de la aserción, que luassert recoge como arguments[3] para usarlo como mensaje de fallo. Cada caso ordena una copia creada por el helper local copyArray, ya que los fixtures son constantes de módulo y las tablas son mutables. Busted contabiliza tests y no aserciones, por eso el resumen muestra 3 successes para las 24 comprobaciones. La bandera swapped se implementa con if not swapped then break end, y insertion_sort desplaza con arr[j] > key estricto, lo que la hace estable. Ubicación desviada de la especificación: src/naive_sort.lua (nombre exacto, solo cambia la extensión), test/naive_sort_tests.lua (sufijo plural _tests.lua, como recursive_tests.lua de numbers/) y ausencia de test/run_tests.ext equivalente porque Busted descubre y ejecuta la suite con su propio runner. Observación menor pendiente de decisión del autor: el encabezado de src/naive_sort.lua conserva el comentario «Contrato pendiente de implementación» del andamiaje, ya desactualizado. El índice de fase lua/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): nim Código verificado / Code verified: yes (sin mitigaciones tras retirar las guardas arr.nil y sustituir la multiasignación por intercambios con temp) Tests y comandos / Tests and commands:

nim check --hints:off src/naive_sort.nim -> sin Error ni Warning (exit 0); nim check es el verificador semántico del propio compilador y no genera binario
nim check --hints:off test/naive_sort_tests.nim -> sin Error ni Warning (exit 0), sin el aviso UnusedImport que aparecía antes
nimble test -> [Suite] naive_sort con [OK] selection_sort, [OK] bubble_sort y [OK] insertion_sort (exit 0; 3 tests, uno por algoritmo, con los 7 casos como check dentro de cada uno = 21 comprobaciones)
nim c -r test/naive_sort_tests.nim -> misma salida que nimble test (la tarea test del .nimble ejecuta exactamente ese comando)
git check-ignore -v test/naive_sort_tests nimcache/x nimblecache/x -> el .gitignore del módulo cubre el binario de test (test/naive_sort_tests) y el de la raíz de nim/ cubre nimcache/ y nimblecache/; ambos se eliminaron tras las pruebas y no quedó ningún artefacto
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo arr[j] < arr[minIndex] por arr[j] > arr[minIndex] en selectionSort -> [FAILED] selection_sort con selection_sort should sort an unsorted array, was @[9, 6, 5, 5, 2, 1] y expected @[1, 2, 5, 5, 6, 9], más los casos del array ya ordenado y del inverso; bubble_sort e insertion_sort siguieron [OK]; revertido -> verde README(s) verificado(s) / README(s) verified: yes (nim/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 28/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua) -> 29/49 (…, Kotlin, Lua, Nim) Observaciones / Notes: Vigesimonovena implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. El proyecto se inició con nimble init, que genera un layout ajeno a la convención (tests/ en plural con test1.nim, un submódulo de ejemplo src/naive_sort/submodule.nim con Submodule/initSubmodule, un proc add* de muestra, versión 0.1.0, autor yorche3, licencia GPL y ninguna tarea test); se reestructuró al patrón de numbers/ (test/ en singular, version = "1.0.0", author = "yorche", MIT, requires "nim >= 2.0.0" y task test con exec "nim c -r test/naive_sort_tests.nim"), se eliminó el código de ejemplo y se añadió el .gitignore del módulo. El caso nulo se omite: seq[int] no admite nil en Nim 2.2 (var s: seq[int] = nil da type mismatch: got 'typeof(nil)' for 'nil' but expected 'seq[int]') y s.isNil tampoco existe (undeclared field: 'isNil'), de modo que una entrada nula no es representable en la firma; la representación alternativa que menciona la especificación (Option/Maybe vacío) queda fuera de alcance porque esta fase todavía no introduce ese tipo, así que se conservan los 7 casos obligatorios y la guarda if n < 1: return arr cubre el array vacío. Los procedimientos usan camelCase (selectionSort), convención de Nim, y el nombre de la especificación (selection_sort) se conserva como nombre del test. Los tres reciben el array como var seq[int] y lo ordenan in-place, sin estructuras auxiliares; como con ARC la asignación entre seq copia el búfer, los tests aíslan cada caso con un helper copyArray sobre los fixtures compartidos. Los intercambios usan una let temp explícita porque Nim solo admite la multiasignación entre paréntesis ((a, b) = (b, a)). La bandera swapped se implementa con if not swapped: break y insertionSort desplaza con arr[j] > key estricto, lo que la hace estable. Las cotas usan rangos semiabiertos (0..<n-1, i+1..<n, 0..<n-i-1), equivalentes a las del pseudocódigo sin desplazamientos manuales. El helper de los tests es una plantilla y no un proc: un check dentro de un proc imprime el fallo y deja el proceso con código distinto de cero, pero unittest sigue marcando el test como [OK], mientras que con la plantilla se marca [FAILED]; el mensaje del contrato se antepone con checkpoint, porque check no admite mensaje propio. Ubicación desviada de la especificación: src/naive_sort.nim (nombre exacto, solo cambia la extensión), test/naive_sort_tests.nim (sufijo plural _tests.nim, como recursive_tests.nim de numbers/) y ausencia de test/run_tests.ext equivalente porque la tarea test del .nimble ejecuta la suite. El índice de fase nim/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): ocaml Código verificado / Code verified: yes (la primera versión del autor usaba sintaxis que no es OCaml —let mutable, break y arr.(min_index) sin !— y no compilaba; se reescribió con ref y con la salida temprana expresada como condición del while externo) Tests y comandos / Tests and commands:

dune build @all -> sin salida y exit 0; el perfil dev de Dune activa un conjunto amplio de warnings y los trata como errores, así que la compilación es la verificación estática
dune runtest -> Testing \naive_sort’. con [OK] naive_sort 0 selection_sort., [OK] naive_sort 1 bubble_sort. y [OK] naive_sort 2 insertion_sort., más Test Successful in 0.001s. 3 tests run. (exit 0; 3 tests, uno por algoritmo, con los 7 casos como check` dentro de cada uno = 21 comprobaciones)
git check-ignore -v core/algorithms/naive_sort/_build/default/x core/algorithms/naive_sort/x.cmi core/algorithms/naive_sort/x.annot -> .gitignore:19:_build/, .gitignore:4:*.cmi y .gitignore:1:*.annot, todas del .gitignore de la raíz de ocaml/; _build/ se eliminó tras las pruebas y no quedó ningún artefacto

Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo arr.(j) < arr.(!min_index) por arr.(j) > arr.(!min_index) en selection_sort -> [FAIL] naive_sort 0 selection_sort. con ASSERT selection_sort should sort an unsorted array, Expected: \[ 1; 2; 5; 5; 6; 9 ]’ y Received: `[|9; 6; 5; 5; 2; 1|]’, más 1 failure! in 0.000s. 3 tests run., mientras bubble_sort e insertion_sort seguían [OK]`; revertido -> verde

Prueba de recorrido en la misma copia: rompiendo solo el caso del array vacío se obtiene FAIL selection_sort should sort an empty array, lo que confirma que el helper llega hasta el séptimo caso README(s) verificado(s) / README(s) verified: yes (ocaml/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 29/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim) -> 30/49 (…, Lua, Nim, OCaml) Observaciones / Notes: Trigésima implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. El proyecto se inició con dune init proj naive_sort, que genera un layout ajeno a la convención: un ejecutable de ejemplo en bin/ (main.ml con print_endline "Hello, World!"), una librería vacía en lib/, un naive_sort.opam generado y un dune-project con (lang dune 3.24), generate_opam_files activado y marcadores de posición (username/reponame, "Author Name"); se reestructuró al patrón de numbers/ ((lang dune 3.0), (name naive_sort), librería en src/ en vez de lib/, (test (name naive_sort_tests) (libraries naive_sort alcotest))) y se eliminaron bin/, lib/ y el .opam. La primera versión de la implementación no era OCaml válido: usaba let mutable min_index = i in (sintaxis de F#/Reason), break (que OCaml no tiene) y arr.(min_index) en lugar de arr.(!min_index), lo que producía Syntax error after unclosed begin, expecting 'open'; se reescribió con ref para los acumuladores mutables del pseudocódigo y con while !i < n - 1 && !swapped para la salida temprana de bubble, que en OCaml no puede escribirse como el if not swapped then break del pseudocódigo pero tiene el mismo comportamiento observable y el mismo mejor caso O(n). El caso nulo se omite: OCaml no tiene null/nil y un int array siempre es un array válido, así que la entrada nula no es representable en la firma; la representación alternativa que menciona la especificación (Option/Maybe vacío) queda fuera de alcance porque esta fase todavía no introduce ese tipo, y la guarda if n <= 1 then arr cubre el array vacío, probado como caso 7. Las funciones usan snake_case (selection_sort), que coincide con el nombre de la especificación, así que la API no necesita traducción. El array es intrínsecamente mutable y se ordena in-place, con los tres algoritmos devolviendo ese mismo array; los tests aíslan cada caso con Array.copy sobre los fixtures compartidos. La suite usa el testable Alcotest.array Alcotest.int en lugar de comparar con = y check bool, para que el fallo muestre los arrays esperado y obtenido, y pasa el mensaje del contrato como segundo argumento de Alcotest.check, que lo imprime como ASSERT y FAIL. sort llega al helper como función de primera clase (Naive_sort.selection_sort). A diferencia de numbers/, el módulo no incluye un src/naive_sort.mli: como no hay helpers privados que ocultar, expone exactamente las tres funciones del contrato, igual que calculator/, que tampoco lo tiene. Ubicación desviada de la especificación: src/naive_sort.ml (nombre exacto, solo cambia la extensión), test/naive_sort_tests.ml (sufijo plural _tests.ml, como recursive_tests.ml de numbers/) y ausencia de test/run_tests.ext equivalente porque Dune descubre y ejecuta el ejecutable declarado en test/dune. El índice de fase ocaml/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): perl Código verificado / Code verified: yes (la primera versión recibía y devolvía una lista, mientras que la suite pasa un arrayref; se autorizó reescribirla con la API por arrayref) Tests y comandos / Tests and commands:

perl -c src/naive_sort.pl -> src/naive_sort.pl syntax OK (exit 0) y perl -c test/naive_sort_tests.pl -> test/naive_sort_tests.pl syntax OK (exit 0); perlcritic no está instalado, así que perl -c es la verificación estática disponible
prove --ext=.pl test/ -> test/naive_sort_tests.pl .. ok, All tests successful., Files=1, Tests=3, 0 wallclock secs y Result: PASS (exit 0; 3 subtests, uno por algoritmo, con los 8 casos como is_deeply dentro de cada uno = 24 comprobaciones, contadas con prove -v)
perl test/naive_sort_tests.pl -> ok 1 - Subtest: selection_sort, ok 2 - Subtest: bubble_sort, ok 3 - Subtest: insertion_sort y plan 1..3
Comprobación del contrato in-place: my $a = [3, 1, 2]; my $r = selection_sort($a); deja $a en 1,2,3 y $r == $a es cierto; selection_sort(undef) devuelve undef y selection_sort([]) devuelve un arrayref definido
git check-ignore -v core/algorithms/naive_sort/naive_sort.o core/algorithms/naive_sort/blib/x core/algorithms/naive_sort/pm_to_blib -> solo coincide .gitignore:6:*.o; los patrones /blib/ y /pm_to_blib están anclados a la raíz de perl/, así que no cubrirían un blib/ dentro del módulo. No es un problema aquí porque el módulo no tiene Makefile.PL y prove no genera artefactos: el módulo solo contiene src/ y test/
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo $arr->[$j] < $arr->[$min_index] por $arr->[$j] > $arr->[$min_index] en selection_sort -> not ok 1 - selection_sort should sort an unsorted array, not ok 2 - selection_sort should sort an already sorted array, not ok 3 - selection_sort should sort a reverse ordered array y not ok 5 - selection_sort should sort an array with negative numbers, con not ok 1 - Subtest: selection_sort frente a ok 2 - Subtest: bubble_sort y ok 3 - Subtest: insertion_sort; revertido -> Result: PASS con las 24 comprobaciones README(s) verificado(s) / README(s) verified: yes (perl/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 30/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml) -> 31/49 (…, Nim, OCaml, Perl) Observaciones / Notes: Trigésima primera implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. La estructura de este lenguaje es manual (✍️ mkdir -p src test en la guía), como en numbers/; no hay comando de andamiaje. La primera versión de la implementación usaba la convención de lista (my @array = @_; y return @array;), mientras que la suite pasa un arrayref, lo que hacía fallar las 24 comprobaciones con GOT: 1 frente a CHECK: <ARRAY>: con un solo argumento, @array es una lista de un elemento y $n vale 1, así que ningún caso ordenaba nada. El autor autorizó reescribirla con la API por arrayref, que es además la única forma de que el ordenamiento sea realmente in-place sobre los datos del llamador, porque un sub de Perl recibe siempre una lista de argumentos. El caso nulo se incluye, a diferencia de Nim y OCaml: Perl tiene undef como valor de «ausencia de valor», así que return undef unless defined $arr; es el indicador de fallo idiomático y defined $arr distingue [] de undef, dando 8 casos (los 7 de la especificación más el nulo). Los tres algoritmos ordenan in-place el arrayref recibido y devuelven ese mismo arrayref, y los tests aíslan cada caso con [@$input] sobre los fixtures compartidos. La comparación usa is_deeply porque is compararía las direcciones de los arrayrefs y no sus contenidos. El helper recibe la función como referencia (\&selection_sort) y ejecuta los 8 casos con el mensaje del contrato como nombre de la aserción, de modo que un fallo aparece como not ok 1 - selection_sort should sort an unsorted array. La bandera swapped se implementa con last unless $swapped;, que es el break de Perl y equivale literalmente al if not swapped then break del pseudocódigo. Las cotas reproducen las del pseudocódigo porque el rango .. de Perl es inclusivo en ambos extremos y devuelve lista vacía cuando la cota superior es menor que la inferior, así que no hacen falta guardas para arrays de 0 o 1 elementos. insertion_sort desplaza con $arr->[$j] > $key estricto, lo que la hace estable. Las funciones usan snake_case (selection_sort), que coincide con el nombre de la especificación, y son sub globales del paquete main a los que la suite llega por nombre tras el require. Ubicación desviada de la especificación: src/naive_sort.pl (nombre exacto, solo cambia la extensión), test/naive_sort_tests.pl (sufijo plural _tests.pl, como recursive_tests.pl de numbers/) y ausencia de test/run_tests.ext equivalente porque prove descubre y ejecuta las suites con --ext=.pl test/. El índice de fase perl/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): prolog Código verificado / Code verified: yes (la primera versión implementaba el mismo algoritmo tres veces —los tres helpers eran idénticos, con el mismo md5, y bubble_sort no tenía bandera de intercambio—; se reescribió con pick_min/3 para selection, bubble_pass/3 para bubble e insert/3 para insertion) Tests y comandos / Tests and commands:

swipl -q -g "consult('src/naive_sort.pl'), halt" -> sin salida y exit 0; Prolog no compila a un artefacto previo, así que consultar el fichero es la verificación estática (avisa de variables singulares y cláusulas mal formadas)
swipl -q -f test/naive_sort_tests.pl -t halt (desde test/) -> % [1/3] naive_sort_tests:selection_sort ............. passed (0.003 sec), % [2/3] naive_sort_tests:bubble_sort ................ passed (0.000 sec) y % [3/3] naive_sort_tests:insertion_sort ............. passed (0.000 sec) (exit 0; 3 tests, uno por algoritmo, con los 7 casos como assertion dentro de cada uno = 21 comprobaciones)
Sin avisos de choicepoint: swipl -q -f test/naive_sort_tests.pl 2>&1 | grep -ci choicepoint -> 0
Los tres helpers ya no son el mismo: los md5 de smallest/3, bubble_pass/3 e insert/3 son 7ec8f437…, facc03b8… y 13885a63…
Bandera de salida temprana verificada de forma aislada: bubble_pass([1,2,3,4,5], R, F) -> R = [1,2,3,4,5], F = false (una lista ya ordenada se resuelve en una pasada, mejor caso O(n)); bubble_pass([5,2,9,1,5,6], R, F) -> R = [2,5,1,5,6,9], F = true (la pasada arrastra el mayor al final)
Los tres predicados coinciden con la especificación: para [3,-1,4,-5,0] los tres devuelven [-5,-1,0,3,4]
git check-ignore -v core/algorithms/naive_sort/src/naive_sort.qlf -> core/algorithms/naive_sort/.gitignore:2:*.qlf; comprobado con swipl -q -g "qcompile('src/naive_sort.pl')" que .qlf es el único artefacto que genera SWI (la raíz de prolog/ no tenía .gitignore)
Contra-verificación A en copia desechable (/tmp, ya eliminada): invirtiendo Y < Mejor por Y > Mejor en smallest/3 -> solo selection_sort **FAILED**, con cuatro aserciones reportadas, la primera Assertion: user:should_sort(selection_sort,an_unsorted_array,[9,6,5,5,2,1],[1,2,5,5,6,9]), mientras bubble_sort e insertion_sort seguían passed; revertido -> verde
Contra-verificación B: invirtiendo X > Y por X < Y en bubble_pass/3 -> solo bubble_sort **FAILED**, con cuatro aserciones y selection_sort e insertion_sort en passed; revertido -> verde
Recuento del fixture: findall(D, case(D,_,_), L), length(L, N) -> N = 7 README(s) verificado(s) / README(s) verified: yes (prolog/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 31/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl) -> 32/49 (…, OCaml, Perl, Prolog) Observaciones / Notes: Trigésima segunda implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. La estructura de este lenguaje es manual (✍️ mkdir -p src test en la guía), como en numbers/. La primera versión de la implementación implementaba el mismo algoritmo tres veces: selection_sort/2 y bubble_sort/2 eran insertion sort recursivo con los helpers insert_min/3, insert_bubble/3 e insert/3 byte a byte idénticos (mismo md5 2e470633…), de modo que no había búsqueda del mínimo ni comparación de adyacentes, y bubble_sort carecía de la bandera de intercambio que exige el criterio de aceptación. La suite pasaba igualmente (3 passed), porque los tres devolvían una lista correctamente ordenada y la bandera no es observable en la salida: lo detectó la compuerta 2 (comparación código ↔ pseudocódigo), no la de tests. Se reescribió con tres estrategias distintas: selection_sort/2 con pick_min/3 (que busca el mínimo con smallest/3 y lo retira con remove_first/3, conservando el orden del resto) para reproducir el «mínimo al inicio» del pseudocódigo; bubble_sort/2 con bubble_pass/3, que compara pares adyacentes, arrastra el mayor al final y devuelve la bandera de intercambio como tercer argumento, de modo que el bucle exterior solo repite si hubo intercambio (el if not swapped then break del pseudocódigo, con mejor caso O(n) verificado de forma aislada); e insertion_sort/2 con insert/3. Las listas de Prolog son inmutables y el lenguaje no tiene asignación, así que ningún algoritmo puede ordenar in-place: los tres devuelven una lista nueva, lo que la especificación permite explícitamente («de forma in-place o retornando una copia ordenada según el paradigma del lenguaje»), y por eso los tests no necesitan copiar el fixture. El caso nulo se omite: en Prolog el array es una lista y una lista no admite null ni una entrada nula, así que el caso no es representable; la representación alternativa que menciona la especificación (Option/Maybe vacío o Result de error) queda fuera de alcance porque esta fase todavía no introduce ese tipo, y el array vacío se prueba como caso 7. Los predicados usan snake_case (selection_sort), que coincide con el nombre de la especificación, y el array se llama Arr en todos ellos (el arr de la documentación), con los identificadores en inglés y los comentarios en español. Los helpers usan ! después de la guarda para ser deterministas y no dejar choicepoints; poner el corte antes de la condición compromete la cláusula y le impide recaer en la siguiente. plunit en SWI 10.0.2 no admite mensaje en assertion/1 (no existen assertion/2 ni /3), así que el mensaje del contrato viaja como el goal que plunit imprime al fallar: assertion(should_sort(Algorithm, Description, Actual, Expected)) con should_sort(_,_,A,E) :- A == E., lo que produce Assertion: user:should_sort(selection_sort,an_unsorted_array,[9,6,5,5,2,1],[1,2,5,5,6,9]); además plunit informa de todas las aserciones fallidas de un test, no solo de la primera. El helper compartido recibe el nombre del predicado y construye el goal con =.., y recorre los casos con forall/2. Ubicación desviada de la especificación: src/naive_sort.pl (nombre exacto, solo cambia la extensión), test/naive_sort_tests.pl (sufijo plural _tests.pl, como recursive_tests.pl de numbers/) y ausencia de test/run_tests.ext equivalente porque la propia suite se ejecuta con la directiva :- initialization(run_tests(naive_sort_tests), main).. El índice de fase prolog/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): purescript Código verificado / Code verified: yes (los tres algoritmos tienen estrategias y helpers distintos: pickMin busca el mínimo y devuelve el valor junto al resto para selection, bubblePass compara adyacentes y devuelve la bandera de intercambio para bubble, e insert coloca el elemento en su sitio para insertion; ningún helper se comparte entre algoritmos. La implementación se reescribió sobre Data.List para dejar de usar Maybe: la versión anterior recorría el Array con uncons y un tipo opcional) Tests y comandos / Tests and commands:

spago build -> Warnings 0 0 0 / Errors 0 0 0 (columnas Src, Lib y All) con ✓ Build succeeded.; purs compila con los avisos activados, así que compilar es la verificación estática. Al compilar desde cero, la propia biblioteca test-unit-17.0.0 emite 15 avisos sobre sus ficheros (10 UnusedName y 5 UnusedDeclaration, en .spago/p/test-unit-17.0.0/src/Test/Unit.purs y Test/Unit/Assert.purs) que no provienen de este módulo: la columna Src, que cuenta el código propio, marca 0; al cambiar las dependencias a lists Spago regeneró spago.lock con Lockfile is out of date (reason: workspace packages changed), generating it...
spago test -> 🍝, - Suite: naive_sort, ✓ Passed: selection_sort, ✓ Passed: bubble_sort, ✓ Passed: insertion_sort, All 3 tests passed! y ✓ Test succeeded for package "naive-sort-algorithms"., con exit 0 (3 tests, uno por algoritmo, con los 7 casos como aserciones dentro de cada uno = 21 comprobaciones)
git check-ignore -v core/algorithms/naive_sort/output core/algorithms/naive_sort/.spago core/algorithms/naive_sort/node_modules -> rc=0 para los tres (.gitignore:1:output/, .gitignore:2:.spago/ y .gitignore:3:node_modules/); git check-ignore -v core/algorithms/naive_sort/spago.lock -> rc=1, es decir, spago.lock sí queda versionado
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo if x > y then por if x < y then en bubblePass -> ☠ Failed: bubble_sort because bubble_sort should sort an unsorted array: expected (1 : 2 : 5 : 5 : 6 : 9 : Nil) but got (9 : 6 : 5 : 5 : 2 : 1 : Nil) con 1 test failed: y exit 1, mientras selection_sort e insertion_sort seguían en ✓ Passed; revertido -> verde README(s) verificado(s) / README(s) verified: yes (purescript/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 32/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog) -> 33/49 (…, OCaml, Perl, Prolog, PureScript) Observaciones / Notes: Trigésima tercera implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. Los comentarios estaban desalineados con la convención acordada: el fichero tenía tres banners en inglés (-- Selection Sort, -- Bubble Sort y -- Insertion Sort) y tres comentarios -- Helper: …; se sustituyeron por descripciones en español con los identificadores y funciones en inglés, y el código de los algoritmos no cambió. En una segunda revisión el autor señaló que el módulo usaba Maybe, el equivalente a Option, que esta fase no usa: con Array no hay forma total de obtener el primero y el resto sin un tipo opcional, porque el compilador rechaza el patrón cons sobre un array (Operator Data.Array.(:) cannot be used in a pattern as it is an alias for function Data.Array.cons, error InvalidOperatorInBinder; verificado con purs compile sobre un fichero de prueba) y todos los accesores de Data.Array (uncons, head, tail, index, last, init, find) devuelven Maybe, mientras que la única alternativa sin Maybe es Data.Array.Partial (head/tail parciales que exigen unsafePartial). Los patrones literales [] y [x] sí compilan, pero no permiten separar cabeza y cola. Decisión del autor: pasar el módulo a Data.List, que sí tiene el constructor cons como dato (x : xs, Nil), es inmutable y es la secuencia recursiva idiomática, igual que en Haskell y Elm y que en el resto de lenguajes funcionales homologados de la fase; con ello desaparece todo tipo opcional del módulo y de los tests, que también se migraron a List Int (fixtures escritos como 5 : 2 : 9 : 1 : 5 : 6 : Nil). La guía indica el andamiaje 🔧 spago init; comprobado en /tmp, genera spago.yaml, .gitignore, .purs-repl, un src/Main.purs de ejemplo con main :: Effect Unit y un test/Test/Main.purs, con package.name tomado del directorio, solo las dependencias console, effect y prelude, test.dependencies vacío y el package set 81.1.0. Se sustituyó por la convención ya homologada de foundations/numbers/: el paquete lleva el sufijo -algorithms (naive-sort-algorithms) para no colisionar con el paquete purescript-numbers del que depende test-unit, se añaden lists y foldable-traversable (ninguna otra biblioteca), el package set se fija en 80.8.1 (la versión ya verificada en numbers/), se declara test-unit como dependencia de test y se elimina el src/Main.purs de ejemplo porque el módulo es una biblioteca. Las listas de PureScript son inmutables y el lenguaje no tiene bucles ni asignación, así que ningún algoritmo puede ordenar in-place: los tres devuelven una lista nueva, lo que la especificación permite explícitamente («de forma in-place o retornando una copia ordenada según el paradigma del lenguaje»), y por eso los tests no necesitan copiar el fixture. El caso nulo se omite: PureScript no tiene null y una List Int no admite una entrada nula, de modo que el caso no es representable en la firma; la representación alternativa que menciona la especificación (Maybe/Option vacío o Result de error) queda fuera de alcance porque esta fase todavía no introduce ese tipo, así que se conservan los 7 casos obligatorios y el caso base cubre las listas de 0 y 1 elementos (el if n <= 1 return arr del pseudocódigo). Sin bucles, los tres algoritmos son recursión estructural con patrones cons (x : xs, Nil), sin uncons ni ningún tipo opcional; bubblePass devuelve Tuple (List Int) Boolean con la bandera de intercambio como segundo componente, y el bucle exterior solo repite si la bandera es true, lo que conserva la salida temprana y el mejor caso O(n) del pseudocódigo (if not swapped then break). insert coloca el elemento delante del primer mayor o igual (x <= y), lo que hace estable a insertionSort. Las funciones usan camelCase (selectionSort), convención de PureScript, y el nombre snake_case de la especificación (selection_sort) se conserva como nombre del test, de modo que el reporte sigue mostrando selection_sort, bubble_sort e insertion_sort; los helpers pickMin, bubblePass e insert no se exportan y no hay main() en el módulo, porque el punto de entrada es el main de Test.Main. Assert.equal no admite mensaje, así que la comparación usa Assert.assert :: String -> Boolean -> Aff Unit con el mensaje primero, compuesto con los valores incluidos (bubble_sort should sort an unsorted array: expected (1 : 2 : 5 : 5 : 6 : 9 : Nil) but got (9 : 6 : 5 : 5 : 2 : 1 : Nil)); el helper compartido recibe la función como valor y recorre los 7 casos con for_, así que las aserciones se escriben una sola vez y no tres. Ubicación desviada de la especificación: src/NaiveSort.purs (los módulos de PureScript van en PascalCase y el fichero debe llamarse como el módulo, igual que Numbers.purs), test/NaiveSortTests.purs (convención PascalCase en plural de numbers/, como RecursiveTests.purs) y ausencia de test/run_tests.ext equivalente porque Spago ejecuta el main declarado en test.main (Test.Main). La secuencia del contrato es List Int en vez del array de la especificación: es la misma desviación que ya asumieron los demás lenguajes funcionales homologados ([Int] en Haskell y F#, List en Elm, Erlang, Elixir y Gleam), y es la única forma de obtener cabeza y cola sin un tipo opcional. El índice de fase purescript/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): python Código verificado / Code verified: yes (la primera versión de bubble_sort no tenía la bandera swapped ni el break: incumplía el criterio de aceptación de salida temprana y degradaba el mejor caso de O(n) a O(n²), y lo detectó la compuerta 2 —comparación código ↔ pseudocódigo— porque la bandera no es observable en la salida; el autor la corrigió. selection_sort intercambia siempre, sin la guarda min_idx != i del pseudocódigo, lo que es una operación nula cuando min_idx == i y no cambia el resultado observable) Tests y comandos / Tests and commands:

python3 -W error -m py_compile src/naive_sort.py tests/naive_sort_tests.py conftest.py -> sin salida y exit 0; Python no compila a un artefacto previo, así que la compilación a bytecode con los avisos como errores es la verificación estática. El entorno del repositorio no tiene linters instalados (ruff, flake8, pylint y mypy no están disponibles)
pytest -v -> collected 3 items, tests/naive_sort_tests.py::test_selection_sort PASSED, ::test_bubble_sort PASSED, ::test_insertion_sort PASSED y 3 passed in 0.01s, con exit 0 (3 tests, uno por algoritmo, con los 8 casos como assert dentro de cada uno = 24 comprobaciones)
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo if arr[j] < arr[min_idx]: por if arr[j] > arr[min_idx]: en selection_sort -> 1 failed, 2 passed in 0.01s, con tests/naive_sort_tests.py::test_selection_sort FAILED y assert [9, 6, 5, 5, 2, 1] == [1, 2, 5, 5, 6, 9]; revertido -> verde. La bandera de bubble_sort no es observable en la salida, así que su presencia se comprobó comparando el código con el pseudocódigo
git check-ignore -v __pycache__/x.pyc .pytest_cache tests/__pycache__/y.pyc -> rc=0 para los tres (.gitignore:1:__pycache__/ y .gitignore:3:.pytest_cache/) README(s) verificado(s) / README(s) verified: yes (python/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 33/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript) -> 34/49 (…, OCaml, Perl, Prolog, PureScript, Python) Observaciones / Notes: Trigésima cuarta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. El esqueleto sigue la convención ya homologada de foundations/numbers/ (src-layout): pyproject.toml (PEP 621 más [tool.pytest.ini_options]), conftest.py que añade src/ a sys.path, src/naive_sort.py y tests/naive_sort_tests.py; la guía marca 🔧 uv init --lib, pero uv no está instalado y el módulo ya homologado manda. El caso nulo se incluye, a diferencia de Haskell, Elm y PureScript: en Python una lista puede ser None, así que el indicador de fallo del contrato es None (if arr is None: return None), distinguible del caso vacío y sin lanzar excepciones; la suite tiene 8 casos (los 7 de la especificación más el nulo) y el helper compartido pasa None tal cual y una copia (list(source)) en el resto. Las listas son mutables, así que los tres algoritmos ordenan in-place y devuelven la misma referencia, lo que la especificación permite explícitamente; por eso cada caso ordena una copia del fixture compartido. insertion_sort desplaza con arr[j] > key estricto, lo que la hace estable. bubble_sort conserva la bandera swapped y el if not swapped: break; el bucle exterior recorre range(n) en lugar del 0 to n - 2 del pseudocódigo, pero la pasada extra tiene el rango interno vacío (n - i - 1 == 0), deja la bandera en False y sale por el break, con el mismo resultado observable. Ubicación desviada de la especificación: src/naive_sort.py (nombre exacto del módulo, solo cambia la extensión), tests/naive_sort_tests.py (directorio en plural y sufijo _tests.py, como tests/recursive_tests.py de numbers/ y como exige python_files) y ausencia de run_tests.ext porque pytest trae su propio runner y descubre las funciones test_*. El índice de fase python/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-18 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): r Código verificado / Code verified: yes (la primera versión de selection_sort y bubble_sort llegaba en el bucle exterior a i == n y R abortaba la función con missing value where TRUE/FALSE needed y argument is of length zero, porque el operador : no devuelve vacío ((n+1):n es descendente y 1:0 es c(1, 0)); lo detectó la compuerta 4 y se mitigó acotando los bucles con seq_len(n - 1) y seq_len(n - i)) Tests y comandos / Tests and commands:

Rscript -e 'invisible(parse("src/naive_sort.R"))' -> parse OK; R no compila a un artefacto previo, así que la verificación estática es el análisis sintáctico con parse() más el analizador lintr
Rscript -e 'print(lintr::lint("src/naive_sort.R"))' -> sin hallazgos y exit 0, tras añadir el salto de línea final que marcaba src/naive_sort.R:80:2: style: [trailing_blank_lines_linter] Missing terminal newline
Rscript test/run_tests.R -> ══ Testing naive_sort_tests.R ═══… y [ FAIL 0 | WARN 0 | SKIP 0 | PASS 24 ] Done! (24 expect_equal, 8 por algoritmo; Rscript devuelve exit 0 igualmente, porque test_file() no propaga el fallo)
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo if (arr[j] < arr[min_idx]) por if (arr[j] > arr[min_idx]) en selection_sort -> [ FAIL 4 | WARN 0 | SKIP 0 | PASS 20 ], con las fallas bajo Failure ('naive_sort_tests.R:65:3'): selection_sort y los mensajes del contrato (selection_sort should sort a reverse ordered array, selection_sort should sort an array with negative numbers), mientras bubble_sort e insertion_sort seguían pasando; revertido -> verde
git check-ignore -v .Rhistory out.tar.gz -> rc=0 para los dos (.gitignore:2:.Rhistory y .gitignore:8:*.tar.gz) README(s) verificado(s) / README(s) verified: yes (r/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 34/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python) -> 35/49 (…, OCaml, Perl, Prolog, PureScript, Python, R) Observaciones / Notes: Trigésima quinta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. La estructura es manual (✍️ mkdir -p src test en la guía), como en numbers/, con src/naive_sort.R, test/naive_sort_tests.R y test/run_tests.R; el módulo necesita el punto de entrada porque testthat no descubre archivos *_tests.R con su patrón por defecto (test*). El caso nulo se incluye, como en Perl y Python: en R NULL es representable y is.null() lo distingue del vector vacío, así que el indicador de fallo es NULL y el caso vacío se escribe con integer(0) (el vector vacío tipado), porque c() devuelve NULL y se confundiría con el indicador; la suite tiene 8 casos (los 7 de la especificación más el nulo). R usa copy-on-modify: las tres funciones ordenan su copia local y devuelven el vector con return(arr), así que el ordenamiento no es in-place observable y los tests no necesitan copiar el fixture. insertion_sort desplaza con arr[j] > key estricto y la guarda j >= 1 (numeración 1-based), lo que la hace estable. bubble_sort conserva la bandera swapped y el if (!swapped) break; la bandera no es observable en la salida, así que su presencia se comprueba comparando el código con el pseudocódigo. El bucle exterior del pseudocódigo (0 to n - 2) se escribe con seq_len(n - 1) y el interior de bubble con seq_len(n - i): en R : no devuelve vacío (1:0 es c(1, 0) y (n+1):n es c(n+1, n)), y llegar a i == n con 1:n hacía que arr[n + 1] fuese NA y arr[0] fuese numeric(0), abortando con missing value where TRUE/FALSE needed y argument is of length zero. Ubicación desviada de la especificación: src/naive_sort.R (solo cambia la extensión, como numbers.R), test/naive_sort_tests.R (sufijo en plural, como recursive_tests.R de numbers/) y test/run_tests.R con el mismo nombre que el punto de entrada de numbers/. El índice de fase r/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-19 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): racket Código verificado / Code verified: yes (la primera versión tenía tres fallos y un desajuste de nombres: insertion-sort perdía elementos porque su let insert interno hacía (insert (cdr s)) sin conservar el prefijo ya descartado —devolvía '(9 6) en lugar de '(1 2 5 5 6 9)—, las tres guardas usaban (or (not (list? arr)) (null? arr)) y devolvían #f para la lista vacía, que el contrato pide devolver tal cual, y bubble-sort no tenía bandera swapped ni salida temprana; además la suite llamaba a selection_sort/bubble_sort/insertion_sort mientras el módulo exporta kebab-case (selection-sort, bubble-sort, insertion-sort), lo que abortaba la ejecución con unbound identifier. Todo corregido y verificado) Tests y comandos / Tests and commands:

raco make src/naive_sort.rkt test/naive_sort_tests.rkt test/run_tests.rkt -> sin salida y exit 0; Racket compila a bytecode con raco make, que es el análisis estático del módulo y de las suites (los .zo quedan en compiled/, ignorado por git)
racket test/run_tests.rkt -> 3 success(es) 0 failure(s) 0 error(s) 3 test(s) run (3 test-case, uno por algoritmo, con los 8 casos como check-equal? dentro de cada uno = 24 checks; racket devuelve exit 0 igualmente)
Contra-verificación en copia desechable (/tmp, ya eliminada) y borrando compiled/ antes de ejecutar, porque un .zo heredado ocultaba el cambio del .rkt: invirtiendo (> (list-ref lst i) (list-ref lst (+ i 1))) por (< …) en bubble-sort -> FAILURE con message: "bubble_sort should sort an unsorted array", actual: '(9 6 5 5 2 1) y expected: '(1 2 5 5 6 9), más 2 success(es) 1 failure(s) 0 error(s) 3 test(s) run; revertido -> verde
git check-ignore -v compiled/naive_sort_rkt.zo -> rc=0 (.gitignore:2:compiled/) README(s) verificado(s) / README(s) verified: yes (racket/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 35/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R) -> 36/49 (…, Prolog, PureScript, Python, R, Racket) Observaciones / Notes: Trigésima sexta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. La estructura es manual (✅ mkdir -p src test en la guía), como en numbers/, con src/naive_sort.rkt, test/naive_sort_tests.rkt y test/run_tests.rkt; el módulo usa #lang racket con (provide selection-sort bubble-sort insertion-sort). Naming: los identificadores van en kebab-case (selection-sort), que es la convención de Racket, y los nombres snake_case de la especificación se conservan como nombre de cada test-case y en el mensaje del contrato ("selection_sort should sort an unsorted array"), de modo que el reporte sigue mostrando los nombres de la especificación. Caso nulo/inválido: se incluye, y es el único lenguaje de la fase donde la lista vacía y null son el mismo objeto ((null? '()) da #t): el indicador de fallo es #f (guardas (not (list? arr))), la lista vacía se devuelve tal cual ([(or (null? arr) (null? (cdr arr))) arr], el if n <= 1 return arr del pseudocódigo) y la suite tiene 8 casos (los 7 de la especificación más el inválido). Las listas de Racket son inmutables y list-set devuelve una lista nueva, así que los tres algoritmos construyen una lista nueva y los tests no necesitan copiar el fixture. selection-sort extrae el mínimo con (apply min lst) y el resto con remove; bubble-sort conserva la bandera swapped y repite solo si hubo intercambios (mejor caso O(n); la bandera no es observable en la salida, así que su presencia se verifica contra el pseudocódigo); insertion-sort usa un let insert interno que acumula en skipped el prefijo descartado antes de reinsertarlo (sin reverse final, porque la lista ya se construye en orden ascendente) y es estable por la comparación estricta (< current (car s)). Ubicación desviada de la especificación: src/naive_sort.rkt (solo cambia la extensión, como numbers.rkt), test/naive_sort_tests.rkt (sufijo en plural, como recursive_tests.rkt de numbers/) y test/run_tests.rkt con el mismo nombre y el mismo mecanismo (run-tests de rackunit/text-ui) que en numbers/ y calculator/. El índice de fase racket/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-19 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): raku Código verificado / Code verified: yes (faltaban los is export —el módulo no exportaba nada y la suite fallaba con Undeclared routines— y el bucle interior de bubble-sort usaba el rango exclusivo 0 ..^ $n - 2 - $i donde el pseudocódigo pide la cota inclusiva: hacía una comparación menos por pasada y el mayor no llegaba al final ([5, 2, 9, 1, 5, 6] → [1, 2, 5, 5, 9, 6]). Corregido con is export en las tres subs y 0 .. $n - 2 - $i; además se adaptaron las pruebas a kebab-case (&selection-sort, &bubble-sort, &insertion-sort), conservando los nombres de la especificación en el subtest y en el mensaje) Tests y comandos / Tests and commands:

raku -c lib/NaiveSort.rakumod y raku -c t/naive_sort_tests.rakutest -> Syntax OK; Raku no compila a un artefacto previo, así que esa comprobación sintáctica es la verificación estática (el propio compilador informa de errores y avisos)
prove6 -l t/ -> t/naive_sort_tests.rakutest .. ok, All tests successful., Files=1, Tests=3, 0 wallclock secs y Result: PASS (3 subtests, uno por algoritmo, con los 7 casos como is-deeply() dentro de cada uno = 21 comprobaciones)
Contra-verificación en copia desechable (/tmp, ya eliminada) y borrando .precomp/: invirtiendo if @array[$j] > @array[$j + 1] por < en bubble-sort -> fallan los 4 checks que dependen del orden (# Failed test 'bubble_sort should sort an unsorted array', # expected: $[1, 2, 5, 5, 6, 9], # got: $[9, 6, 5, 5, 2, 1], y lo mismo con el array ya ordenado, el inverso y los negativos), con Tests: 3 Failed: 1, Failed tests: 2 y Result: FAILED; selection_sort e insertion_sort siguen en verde; revertido -> verde
git check-ignore -v lib/.precomp/x -> rc=0 (.gitignore:3:lib/.precomp/) README(s) verificado(s) / README(s) verified: yes (raku/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 36/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket) -> 37/49 (…, PureScript, Python, R, Racket, Raku) Observaciones / Notes: Trigésima séptima implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. La estructura es manual (✅ mkdir -p lib t en la guía) y es el layout idiomático de Raku: lib/NaiveSort.rakumod (fichero del módulo en PascalCase, como Numbers.rakumod) y t/naive_sort_tests.rakutest; no hay run_tests porque prove6 descubre t/*.rakutest y es el punto de entrada del ecosistema. Naming: los identificadores van en kebab-case (selection-sort), que es la convención de Raku, y los nombres snake_case de la especificación se conservan como nombre de cada subtest y en el mensaje de cada aserción, de modo que el reporte sigue mostrando los nombres de la especificación. Caso nulo omitido: un parámetro con sigilo @array no admite Nil; es un error de compilación («Calling f(Nil) will never work with declared signature (@arr)»), no de ejecución, así que la entrada nula no es representable en la firma y se conservan los 7 casos obligatorios. Los tres algoritmos ordenan in-place la copia local del parámetro (sin is rw la mutación no sale de la función) y devuelven el array, variante que la especificación permite; por eso la suite ordena un clone del fixture en cada caso. insertion-sort desplaza con @array[$j] > $current estricto y la guarda $j >= 0, lo que la hace estable. bubble-sort conserva la bandera (@swapped[0] y last unless) y la salida temprana del pseudocódigo; la bandera no es observable en la salida, así que su presencia se comprueba contra el pseudocódigo. En Raku 1..0 es un rango vacío, así que las cotas no generan iteraciones fantasma; el cuidado está en no confundir el rango exclusivo ..^ con la cota inclusiva del pseudocódigo. El submódulo sigue en la rama dev, sin rama de trabajo feat/algorithms/naive-sort como en los demás lenguajes. El índice de fase raku/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-19 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): rescript Código verificado / Code verified: yes (la primera versión no compilaba: usaba sintaxis que no existe en la versión fijada (rescript ^11.1.4, la misma que numbers/). Tres correcciones: for i in a .. b → for i in a to b; let mut x = v con x = v2 → ref(v) con x := v2 y lectura x.contents; y break → la bandera swapped como condición del while. Después de corregirlo, compilación limpia y 21/21) Tests y comandos / Tests and commands:

npm run res:build (rescript) -> >>>> Start compiling … >>>> Finish compiling 39 mseconds, sin errores ni avisos; el compilador es también la verificación estática
npm test -> Test Suites: 1 passed, 1 total, Tests: 21 passed, 21 total y exit 0 (21 casos, 7 por algoritmo)
Contra-verificación en copia desechable (/tmp, ya eliminada y sin los .res.mjs generados, que podían enmascarar el cambio): invirtiendo if array[j] < array[min_index.contents] por > en selection_sort -> Test Suites: 1 failed, 1 total, Tests: 4 failed, 17 passed, 21 total, con los fallos nombrados por el mensaje del contrato (● selection_sort › should sort an unsorted array, … an already sorted array, … a reverse ordered array, … an array with negative numbers) y el Expected/Received de Jest; bubble_sort e insertion_sort siguen en verde; revertido -> verde
git check-ignore -v lib/x.bs.js .bsb.lock src/probe.res.mjs node_modules/ package-lock.json -> rc=0 para los cinco README(s) verificado(s) / README(s) verified: yes (rescript/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 37/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket, Raku) -> 38/49 (…, Prolog, PureScript, Python, R, Racket, Raku, ReScript) Observaciones / Notes: Trigésima octava implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. El módulo fija rescript ^11.1.4 (la misma versión que numbers/), así que el código usa la sintaxis de esa versión: bucles for i in a to b, acumuladores con ref/:=/.contents y la salida temprana de bubble_sort en la condición del while (while swapped.contents && i.contents <= n - 2), porque esta versión no tiene break; es el mismo recurso que se usó en OCaml. Los arrays de ReScript son mutables, así que los tres algoritmos ordenan in-place el array recibido y lo devuelven, y la suite ordena una copia por caso (Belt.Array.copy). El caso nulo se omite: array<int> no admite null ni una entrada inválida. insertion_sort desplaza con array[j.contents] > key estricto y la guarda j.contents >= 0, lo que la hace estable. La bandera swapped no es observable en la salida, así que su presencia se verifica contra el pseudocódigo. Jest no admite mensaje como argumento de expect, así que el mensaje del contrato se compone con el nombre del describe (el algoritmo) y el del test (should sort <descripción>): un fallo se reporta como ● selection_sort › should sort an unsorted array. El módulo que genera el compilador a partir del fichero es Naive_sort (ReScript capitaliza la primera letra), de ahí las llamadas Naive_sort.selection_sort. Ubicación desviada de la especificación: src/naive_sort.res (solo cambia la extensión, como numbers.res), test/naive_sort_tests.res (el sufijo en plural que declara testMatch en jest.config.js) y ausencia de run_tests.ext porque Jest trae su propio runner y npm test compila y ejecuta. El submódulo sigue en la rama dev. El índice de fase rescript/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-19 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): rexx Código verificado / Code verified: yes (los gates de la delegación bloquearon la primera versión y se corrigieron cuatro cosas. 1) selection_sort no compilaba: Error 10: Unexpected or unmatched END al cargar el módulo, porque dos if ... then sin do dejaban sin pareja los end de bloque; se añadió el do explícito. 2) La escritura por índice arr~at(i) = v no existe en .Array (Error 97.1: Object "an Array" does not understand message "AT="); se usa la forma de corchetes arr[i] = v (delega en put), manteniendo la lectura arr~at(i). 3) insertion_sort usaba la condición compuesta j > 0 & arr~at(j) > key, pero & no cortocircuita en REXX y evaluaba arr~at(0) (Error 93.907: Method argument 1 must be a positive whole number; found "0"); se reescribió como do while j > 0 con if arr~at(j) <= key then leave. 4) La suite pasaba cadenas separadas por blancos y el módulo espera un .Array, así que la suite conserva las constantes legibles y construye un .Array nuevo por caso (buildArray, porque el orden es in-place) y normaliza ambos lados a texto comparable (asText, porque .Array compara identidad); ambos son métodos de instancia porque una instancia no alcanza los métodos de clase con self~...) Tests y comandos / Tests and commands:

Verificación estática: ❌ no existe analizador estático en ooRexx; rexxc src/naive_sort.rexx solo imprime el banner y sale con 0 sin reportar el END sin pareja, así que la comprobación real es cargar el módulo ejecutando la suite
rexx test/naive_sort_tests.rexx (desde la raíz del módulo: los ::requires relativos resuelven contra el directorio de trabajo) -> nr of test runs: 4, nr of successful assertions: 24, nr of failures: 0, nr of errors: 0 (el intérprete sale con código 0 aunque haya fallos, así que el resultado se lee del resumen)
Contra-verificación en copia desechable (/tmp, ya eliminada): invirtiendo if arr~at(j) < arr~at(min_index) por > en selection_sort -> nr of successful assertions: 16, nr of failures: 1 y el fallo nombrado por el mensaje del contrato (selection_sort should sort an unsorted array, expected=[1 2 5 5 6 9], actual=[9 6 5 5 2 1]); revertido -> verde README(s) verificado(s) / README(s) verified: yes (rexx/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 38/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket, Raku, ReScript) -> 39/49 (…, PureScript, Python, R, Racket, Raku, ReScript, REXX) Observaciones / Notes: Trigésima novena implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. La estructura es manual (✅ mkdir -p src test) y sigue el layout de REXX del repositorio: src/naive_sort.rexx (clase NaiveSort con métodos de clase) y test/naive_sort_tests.rexx (subclase de TestCase con ::requires "OOREXXUNIT.CLS" y ::requires "src/naive_sort.rexx"); no hay run_tests porque la suite se ejecuta directamente con rexx y los ::requires relativos obligan a lanzarla desde la raíz del módulo. Naming: se conservan los nombres snake_case de la especificación, que son válidos y naturales en REXX (case-insensitive), y los métodos de test usan camelCase (testSelectionSort) como en foundations/numbers/. Caso nulo incluido: .Nil es representable y distinguible del array vacío (.array~new), así que el indicador de fallo es .Nil y la suite cubre 8 casos (los 7 de la especificación más el nulo) = 24 aserciones (3 algoritmos × 8 casos). Los tres algoritmos ordenan in-place el .Array recibido y devuelven su referencia, variante que la especificación permite; por eso la suite construye un .Array nuevo por caso. bubble_sort conserva la bandera swapped y la salida temprana con leave (mejor caso $O(n)$; la bandera no es observable en la salida, así que su presencia se verifica contra el pseudocódigo); insertion_sort es estable por la comparación arr~at(j) <= key; selection_sort intercambia con temp, sin operadores que REXX no tenga. Particularidades del lenguaje documentadas en el README: el cuerpo de un ::method es una rutina que termina en return (sin end final, con do explícito en cada bloque), & y | no cortocircuitan, .Array no se compara por contenido con = (compara identidad), do i = 1 to 0 no itera y una instancia no alcanza los métodos de clase con self~.... No hay .gitignore: ooRexx interpreta los fuentes y no genera artefactos. El submódulo está en la rama feat/algorithms/naive-sort. El índice de fase rexx/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-19 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): ruby Código verificado / Code verified: yes (las tres funciones coinciden con el pseudocódigo: selection_sort con (0...n-1) y (i+1...n), bubble_sort con la bandera swapped y break unless swapped —el if not swapped: break del pseudocódigo—, insertion_sort con while j >= 0 && arr[j] > key, estricto y por tanto estable. Ninguna invoca sort, sort_by, min ni ayudas de ordenamiento. Divergencias idiomáticas aceptadas: module NaiveSort con métodos def self.* en lugar de una clase con instancias (mismo patrón que Numbers en core/foundations/numbers/), orden in-place que devuelve la misma referencia —variante que la especificación permite— y nil como indicador de fallo) Tests y comandos / Tests and commands:

Verificación estática: ruby -w -c src/naive_sort.rb y ruby -w -c test/naive_sort_tests.rb -> Syntax OK en ambos, sin warnings (Ruby no compila a un artefacto previo y el módulo no declara linter)
bundle exec rspec -> 3 examples, 0 failures (un ejemplo por algoritmo, 8 casos cada uno = 24 aserciones) README(s) verificado(s) / README(s) verified: yes (ruby/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 39/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX) -> 40/49 (…, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby) Observaciones / Notes: Cuadragésima implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. La estructura es manual (✅ mkdir -p src test + bundle init, como indica la guía) y sigue el patrón de numbers/ y calculator/: src/naive_sort.rb (módulo con métodos self.*), test/naive_sort_tests.rb, Gemfile (rspec ~> 3.13), .rspec (--format documentation, --default-path test, --pattern "**/*_tests.rb") y .gitignore (.bundle/, vendor/bundle/, Gemfile.lock; verificado con git check-ignore -v Gemfile.lock .bundle/config vendor/bundle/x -> las tres coinciden). Naming: los nombres snake_case de la especificación (selection_sort, bubble_sort, insertion_sort) son también la convención de Ruby, así que no hubo adaptación; la suite los conserva en el nombre de cada describe y en el mensaje del contrato (selection_sort should sort an unsorted array). Caso nulo incluido: un array de Ruby puede ser nil, así que el indicador de fallo es nil, distinguible del array vacío ([]), y la suite cubre 8 casos (los 7 de la especificación más el nulo) = 24 aserciones. Los tres algoritmos ordenan in-place y devuelven la misma referencia, variante que la especificación permite, así que la suite define fixtures congelados con freeze y ordena una copia dup por caso (aislamiento). La bandera swapped no es observable en la salida, así que su presencia se comprueba contra el pseudocódigo. Particularidades documentadas en el README: && sí cortocircuita (por eso la guarda j >= 0 protege arr[j] en insertion_sort), los for del pseudocódigo se traducen a rangos exclusivos (0...n-1) / (0...n-i-1) por el índice 0-based, y el intercambio usa asignación paralela. Ubicación desviada de la especificación: src/naive_sort.rb (solo cambia la extensión), test/naive_sort_tests.rb (sufijo en plural, como recursive_tests.rb de numbers/) y ausencia de run_tests.rb porque bundle exec rspec descubre la suite con el patrón de .rspec. El submódulo está en la rama feat/algorithms/naive-sort. El índice de fase ruby/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-19 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): rust Código verificado / Code verified: yes (las tres funciones coinciden con el pseudocódigo: selection_sort con 0..n-1 y i+1..n, bubble_sort con la bandera swapped y if !swapped { break; } —el if not swapped: break del pseudocódigo— y insertion_sort con el while j >= 0 and arr[j] > key traducido a while j > 0 && arr[j-1] > key sobre usize, estricto y por tanto estable. El único intercambio es Vec::swap; no se invoca sort, sort_by ni sort_unstable. Divergencias idiomáticas aceptadas: las funciones reciben el Vec<i32> por valor (mut arr) y devuelven el mismo vector reordenado in-place en su propio búfer —variante que la especificación permite—, y el caso nulo se omite porque Vec<i32> no admite null y la fase todavía no usa Option/Result como indicador de fallo) Tests y comandos / Tests and commands:

Verificación estática: cargo clippy --all-targets -- -D warnings -> Checking naive_sort v0.1.0 (...) y Finished \dev` profile … in 0.09s`, sin warnings ni errores
cargo test -> running 3 tests (bubble_sort ... ok, insertion_sort ... ok, selection_sort ... ok) y test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; los doc-tests y los unittests de src/lib.rs corren 0 tests. 3 tests × 7 casos = 21 aserciones
Contra-verificación en copia desechable (/tmp, ya eliminada): con una implementación de sonda la suite dio 3 passed; 0 failed; invirtiendo if arr[j] < arr[min_index] por > en selection_sort -> assertion \left == right` failed: selection_sort should sort an unsorted array y test result: FAILED. 2 passed; 1 failed; revertido -> verde README(s) verificado(s) / README(s) verified: yes (rust/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change:core.algorithms.naive_sort40/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby) -> 41/49 (…, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust) Observaciones / Notes: Cuadragésima primera implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. El andamiaje se hizo con el comando de la guía (✅cargo init –lib), que genera solo la librería, sin main de ejemplo, y después se ajustó Cargo.toml al patrón de foundations/numbers/ ([package] con edition 2024 + [lib] name = “naive_sort”, path = “src/lib.rs”). Layout: src/lib.rs (pub mod naive_sort;), src/naive_sort.rs (las 3 funciones), tests/naive_sort_tests.rs (suite de integración) y .gitignore (target/; verificado con git check-ignore -v target/debug/x -> .gitignore:2:target/). **Naming:** los nombres snake_case de la especificación (selection_sort, bubble_sort, insertion_sort) son también la convención de Rust, así que no hubo adaptación; la suite los conserva en el nombre de cada #[test] y en el mensaje del contrato (selection_sort should sort an unsorted array). **Caso nulo omitido:** Vec` no admite `null` y esta fase todavía no usa `Option`/`Result` como indicador de fallo, así que no es representable en la firma y no hay indicador que comprobar; se conservan los 7 casos de la especificación (mismo criterio que OCaml). Detalles de Rust documentados en el README: los `for` del pseudocódigo se traducen a rangos exclusivos (`0..n-1`, `0..n-i-1`), el `usize` obliga a reescribir el `j >= 0` de `insertion_sort` como `j > 0 && arr[j-1] > key`, y el intercambio usa `Vec::swap`. Ubicación desviada de la especificación: `src/naive_sort.rs` (solo cambia la extensión, como `numbers.rs`), `tests/naive_sort_tests.rs` (layout de integración de Cargo, como `recursive_tests.rs`) y ausencia de `run_tests.rs` porque `cargo test` descubre `tests/` automáticamente. `Cargo.lock` se versiona, como en `numbers/`. El submódulo está en la rama `feat/algorithms/naive-sort`. El índice de fase `rust/core/algorithms/README.md` se creó en este cierre.

Fecha / Date: 2026-09-19 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): scala Código verificado / Code verified: yes (la primera versión compilaba y pasaba los tests, pero el compilador emitía un warning en bubble_sort: NaiveSort.scala:54:8 -> «Non local returns are no longer supported; use boundary and boundary.break in scala.util instead», porque la salida temprana se hacía con un return arr dentro del cuerpo de un for (que Scala convierte en una clausura). Corregido sustituyéndolo por un while (i < n - 1 && swapped) con la bandera del pseudocódigo en la condición: compilación limpia y mismo comportamiento (la bandera no es observable en la salida, así que su presencia y complejidad se verifican contra el pseudocódigo). Las tres funciones coinciden con el pseudocódigo: selection_sort con 0 until n - 1 e i + 1 until n, insertion_sort con el while j >= 0 and arr[j] > key traducido a while (j > 0 && arr(j - 1) > key), estricto y por tanto estable, y los intercambios con temp sin sorted/sortBy/sortWith/scala.util.Sorting. Divergencias idiomáticas aceptadas: orden in-place que devuelve la misma referencia —variante que la especificación permite— y null como indicador de fallo (representable en un array de la JVM)) Tests y comandos / Tests and commands:

Verificación estática: sbt clean compile -> compiling 1 Scala source ... done compiling sin ningún [warn] (antes de la corrección: one warning found)
sbt test -> [info] NaiveSortTests: con - selection_sort, - bubble_sort, - insertion_sort, Total number of tests run: 3, Suites: completed 1, aborted 0 y Tests: succeeded 3, failed 0, canceled 0, ignored 0, pending 0 / All tests passed. (3 tests × 8 casos = 24 aserciones)
Contra-verificación en copia desechable (/tmp, ya eliminada): con una implementación de sonda la suite dio Tests: succeeded 3, failed 0; invirtiendo arr(j) < arr(min_index) por > en selection_sort -> - selection_sort *** FAILED *** Expression was false selection_sort should sort an unsorted array y Tests: succeeded 2, failed 1; revertido -> verde. Se comprobó también con una sonda aparte (for con return interno) que el non-local return seguía funcionando hoy (earlyExit = 99) pese al warning, así que no era un defecto observable en la salida README(s) verificado(s) / README(s) verified: yes (scala/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 41/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust) -> 42/49 (…, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala) Observaciones / Notes: Cuadragésima segunda implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. La estructura es el layout estándar de sbt que ya usa foundations/numbers/ (mkdir -p src/main/scala src/test/scala project, ✅ en la guía), con build.sbt (Scala 3.9.0 + org.scalatest %% scalatest % 3.2.19 % Test), project/build.properties (sbt.version=1.10.1), src/main/scala/NaiveSort.scala, src/test/scala/NaiveSortTests.scala y .gitignore (target/, .bsp/, .scala-build/, .metals/, .idea/; verificado con git check-ignore -v target/scala-3.9.0/classes project/target/x .bsp/settings.json -> los tres coinciden). Naming: los nombres snake_case de la especificación (selection_sort, bubble_sort, insertion_sort) son válidos en Scala y se conservan; la suite los usa como nombre de cada test("...") y en el mensaje del contrato (selection_sort should sort an unsorted array). Caso nulo incluido: un Array[Int] de la JVM admite null, así que el indicador de fallo es null y la suite cubre 8 casos (los 7 de la especificación más el nulo) = 24 aserciones; el caso nulo se comprueba con assert(actual == null, …) porque sameElements no admite null. Los tres algoritmos ordenan in-place y devuelven la misma referencia, variante que la especificación permite, así que la suite ordena una copia clone() por caso (aislamiento). Particularidades documentadas en el README: comparar arrays con sameElements y no con == (que es identidad de referencia), los for del pseudocódigo como rangos until exclusivos y el cuidado con los non-local returns de Scala 3. Ubicación desviada de la especificación: layout sbt (src/main/scala y src/test/scala en lugar de src/naive_sort.ext y test/naive_sort_test.ext) y ausencia de run_tests.scala porque sbt test descubre las suites de ScalaTest. El submódulo está en la rama feat/algorithms/naive-sort. El índice de fase scala/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-19 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): scheme Código verificado / Code verified: yes (la primera versión fallaba las dos suites: # of expected passes 9 de 24 en Guile y aborto en MIT/GNU Scheme con The procedure #[compound-procedure 12 insert] has been called with 3 arguments; it requires exactly 2 arguments.). Cuatro correcciones: 1) selection-sort usaba (remove min unsorted), que es de SRFI-1 y no está en el entorno base de Guile ni de MIT/GNU Scheme (Unbound variable: remove), sustituido por el helper propio remove-first; 2) el let con nombre insert de insertion-sort se llamaba con 3 argumentos teniendo 2 parametros, reescrito con 2 parametros (x y la lista pendiente) que devuelve la lista insertada; 3) el acumulador de insertion-sort se construye ya en orden ascendente, asi que se elimino el reverse final que lo invertia; 4) las tres funciones devolvian '() como indicador de fallo en vez de #f (contrato de las pruebas) y bubble-sort llamaba a (cdr unsorted) con la lista vacia, asi que se anadio la guarda n <= 1 del pseudocodigo. Divergencias idiomaticas aceptadas: orden funcional que devuelve una lista nueva (listas inmutables de Scheme, variante que la especificacion permite), API en kebab-case (selection-sort, bubble-sort, insertion-sort) con los nombres snake_case de la especificacion conservados en los casos y en el mensaje del contrato, y #f como indicador de fallo porque '() es la unica lista vacia) Tests y comandos / Tests and commands:

Verificacion estatica: no hay compilador previo; la comprobacion es la carga del modulo por las suites. Se forzo la recompilacion de Guile y los avisos sobre remove / insert desaparecieron: solo quedan los warning: possibly unbound variable del patron (load "../src/naive_sort.scm"), identicos a los que producen numbers/ y calculator/, que se evitan con --no-auto-compile
guile --no-auto-compile -s naive_sort_tests_guile.scm (desde test/) -> %%%% Starting test naive_sort (Writing full log to "naive_sort.log") y # of expected passes 24, rc=0, sin warnings
SCMUNIT_PATH="$HOME/.local/share/scmunit/scmunit.scm" mit-scheme --quiet --load naive_sort_tests.scm -> 24 lineas # <algoritmo> should sort <caso>: . (0.ms) y 24 checks ran: 24 passed, 0 failed
Contra-verificacion en copia desechable (/tmp, ya eliminada): invirtiendo la seleccion del minimo (min -> max) -> Guile FAIL selection_sort should sort an unsorted array y # of expected passes 20 (4 fallos); scmunit marca x en los mismos casos con el mensaje del contrato; revertido -> verde README(s) verificado(s) / README(s) verified: yes (scheme/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 42/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala) -> 43/49 (…, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme) Observaciones / Notes: Cuadragesima tercera implementacion homologada de la Fase 1. No cierra la fase: faltan los demas lenguajes y los modulos restantes. La estructura es manual (✍️ mkdir -p src test en la guia) y sigue el patron de foundations/numbers/: src/naive_sort.scm y una suite por runtime (test/naive_sort_tests_guile.scm con SRFI-64 y test/naive_sort_tests.scm con scmunit), mas .gitignore con *.log (verificado con git check-ignore -v test/naive_sort.log -> .gitignore:1:*.log); los .log los escribe Guile al ejecutar la suite. Las suites se ejecutan desde test/ porque cargan el modulo con (load "../src/naive_sort.scm"). Naming: la API va en kebab-case y los nombres snake_case de la especificacion se conservan en los casos y en el mensaje del contrato; en scmunit (que no admite mensajes por asercion) el mensaje viaja en el nombre del sub-testcase. Caso nulo incluido: '() no se distingue de la lista vacia, asi que el indicador de fallo es #f (mismo criterio que Racket) y la suite cubre 8 casos (los 7 de la especificacion mas el nulo) = 24 comprobaciones. Los tres algoritmos son funcionales (listas inmutables, devuelven lista nueva), variante que la especificacion permite, asi que los casos pueden usar los fixtures compartidos sin copiarlos. Particularidades documentadas en el README: remove es de SRFI-1 y no esta en el entorno base (helper remove-first propio), (cdr '()) es un error y exige la guarda n <= 1 explicita, la bandera swapped de bubble-sort viaja en el par (lista . bandera) y el acumulador de insertion-sort se construye ya ascendente. Ubicacion desviada de la especificacion: src/naive_sort.scm (solo cambia la extension), dos suites (una por runtime) y ausencia de run_tests.scm. Nota de rama: el submodulo sigue en dev, sin rama de trabajo feat/algorithms/naive-sort (como ocurrio en Raku). El indice de fase scheme/core/algorithms/README.md se creo en este cierre.

Fecha / Date: 2026-09-20 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): swift Código verificado / Code verified: yes (la primera versión pasaba los tests y compilaba sin warnings, pero bubble_sort no tenía la bandera swapped ni la salida temprana —hacía siempre las n - 1 pasadas—, lo que incumplía el criterio de aceptación de la especificación; se añadieron var swapped = false, swapped = true en cada intercambio e if !swapped { break }. Las tres funciones coinciden ahora con el pseudocódigo: selection_sort con 0..<count - 1 y i + 1..<count, insertion_sort insertando con swapAt(j, j - 1) mientras el vecino sea estrictamente mayor (equivalente al desplazamiento del pseudocódigo, misma complejidad y estable). Divergencias idiomáticas aceptadas: los tres algoritmos trabajan sobre una copia local y devuelven un array nuevo (variante «in-place o copia ordenada» que la especificación permite, y [Int] es un tipo de valor), y el caso nulo se omite porque [Int] no admite nil) Tests y comandos / Tests and commands:

Verificación estática: swift build -> [1/1] Planning build, Building for debugging..., [3/3] Emitting module NaiveSort y Build complete! (0.21s), sin warnings
swift test -> Test Case 'NaiveSortTests.testBubbleSort' passed, … testInsertionSort passed, … testSelectionSort passed, Test Suite 'NaiveSortTests' passed y Executed 3 tests, with 0 failures (0 unexpected) in 0.101 (0.101) seconds (3 tests × 7 casos = 21 aserciones)
Contra-verificación en copia desechable (/tmp, ya eliminada): con una implementación de sonda la suite dio Executed 3 tests, with 0 failures; invirtiendo result[j] < result[minIndex] por > en selection_sort -> error: NaiveSortTests.testSelectionSort : XCTAssertEqual failed: ("[9, 6, 5, 5, 2, 1]") is not equal to ("[1, 2, 5, 5, 6, 9]") - selection_sort should sort an unsorted array (y tres fallos más) con Executed 3 tests, with 4 failures (0 unexpected); revertido -> verde README(s) verificado(s) / README(s) verified: yes (swift/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 43/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme) -> 44/49 (…, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift) Observaciones / Notes: Cuadragésima cuarta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. El andamiaje usó el comando de la guía (🔧 swift package init --type library --name NaiveSort), que genera Package.swift, .gitignore, Sources/NaiveSort/NaiveSort.swift y Tests/NaiveSortTests/NaiveSortTests.swift; se conservó el manifiesto generado (swift-tools-version: 6.3, swiftLanguageModes: [.v6]) y se amplió el .gitignore con .build/ y .swiftpm/ además de las entradas del generador (verificado con git check-ignore -v .build/debug/x .swiftpm/x .DS_Store -> las tres coinciden). La plantilla de ejemplo del generador (código de ejemplo y un test con Swift Testing) se sustituyó por el contrato y la suite en XCTest, la convención de numbers/ y calculator/. Naming: los nombres snake_case de la especificación (selection_sort, bubble_sort, insertion_sort) son también los que usan los otros módulos Swift del repositorio, así que no hubo adaptación; los métodos de test van en camelCase (testSelectionSort) y el mensaje del contrato (selection_sort should sort an unsorted array) viaja en el tercer argumento de XCTAssertEqual. Caso nulo omitido: [Int] es un tipo de valor y no admite nil, y esta fase todavía no envuelve el array en Optional, así que no es representable en la firma; se conservan los 7 casos de la especificación. Los tres algoritmos ordenan sobre una copia local (var result = array) y devuelven un array nuevo, variante que la especificación permite, así que los fixtures de la suite no se contaminan (semántica de valor). Particularidades documentadas en el README: los for del pseudocódigo se traducen a rangos semiabiertos (0..<count - 1, 0..<count - 1 - i), el intercambio usa Array.swapAt sin invocar sorted()/sort(), y el espacio de nombres es una clase con métodos estáticos (los otros módulos Swift usan public enum, mismo comportamiento observable). Ubicación desviada de la especificación: layout de Swift Package Manager (Sources/NaiveSort/ y Tests/NaiveSortTests/ en lugar de src/ y test/) y ausencia de run_tests.swift porque swift test es el runner del paquete. El submódulo está en la rama feat/algorithms/naive-sort. El índice de fase swift/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-20 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): tcl-tk Código verificado / Code verified: yes (las tres funciones coinciden con el pseudocódigo: selection_sort con for {set i 0} {$i < $n - 1} {incr i} y $j < $n, bubble_sort con la bandera swapped y el break —el if not swapped: break del pseudocódigo— con el bucle interior $j < $n - 1 - $i, e insertion_sort insertando con lset mientras el vecino sea estrictamente mayor ([lindex $result $j] < [lindex $result [expr {$j - 1}]]), equivalente al desplazamiento del pseudocódigo y estable. El único intercambio es lset sobre la copia local; no se invoca lsort ni lsort -command. Divergencias idiomáticas aceptadas: los algoritmos trabajan sobre una copia local (set result $array) y devuelven una lista nueva —las listas de Tcl son valores y la especificación permite la variante «in-place o copia ordenada»—, y el caso nulo se omite porque Tcl no tiene null/nil y {} es a la vez la lista vacía y la cadena vacía) Tests y comandos / Tests and commands:

Verificación estática: Tcl no tiene compilador ni analizador estático, así que la comprobación es cargar el paquete: TCLLIBPATH="$(cd ../src && pwd)" tclsh9.0 <<< 'package require naive_sort 1.0; puts [info commands ::NaiveSort::*]' -> ::NaiveSort::selection_sort ::NaiveSort::insertion_sort ::NaiveSort::bubble_sort (sin errores; Tcl 9.0.4)
TCLLIBPATH="$(cd ../src && pwd)" tclsh9.0 naive_sort.test (desde test/) -> naive_sort.test: Total 21 Passed 21 Skipped 0 Failed 0 (3 algoritmos × 7 casos = 21)
Contra-verificación en copia desechable (/tmp, ya eliminada): con una implementación de sonda la suite dio Total 21 Passed 21 Skipped 0 Failed 0; invirtiendo [lindex $result $j] < [lindex $result $minIndex] por > en selection_sort -> ==== selection_sort: an unsorted array selection_sort should sort an unsorted array FAILED (y tres fallos más), con el mensaje del contrato; revertido -> verde README(s) verificado(s) / README(s) verified: yes (tcl-tk/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 44/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift) -> 45/49 (…, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk) Observaciones / Notes: Cuadragésima quinta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. La estructura es manual (✍️ mkdir -p src test en la guía) y sigue el patrón de foundations/numbers/ y foundations/unit_test/calculator/: src/naive_sort.tcl (namespace NaiveSort con namespace export y los 3 proc, más package provide naive_sort 1.0 al final), src/pkgIndex.tcl (package ifneeded naive_sort 1.0 …) y test/naive_sort.test, más .gitignore con *.log (verificado con git check-ignore -v test/naive_sort.log -> .gitignore:1:*.log). El paquete se localiza con TCLLIBPATH apuntando a src/ y las suites se ejecutan desde test/. Naming: los nombres snake_case de la especificación (selection_sort, bubble_sort, insertion_sort) son los que usan los otros módulos Tcl del repositorio, así que no hubo adaptación; el namespace va en PascalCase (NaiveSort) y el mensaje del contrato (selection_sort should sort an unsorted array) es la descripción de cada test. Caso nulo omitido: Tcl no tiene null/nil y {} no se distingue de la cadena vacía, así que no es representable y no hay indicador que comprobar; se conservan los 7 casos de la especificación = 21 comprobaciones. Los tres algoritmos ordenan una copia local y devuelven una lista nueva (listas de Tcl como valores), variante que la especificación permite, así que los cases reutilizan los fixtures sin copiarlos. Particularidades documentadas en el README: los intercambios usan lset leyendo antes el valor a sobrescribir, los bucles son for {set …} con índices 0-based y no se invoca lsort. Ubicación desviada de la especificación: src/naive_sort.tcl (solo cambia la extensión), la suite con sufijo .test (como recursive.test de numbers/) y ausencia de run_tests.tcl porque Tcltest imprime el resumen de cada suite. El submódulo está en la rama feat/algorithms/naive-sort. El índice de fase tcl-tk/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-20 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): typescript Código verificado / Code verified: yes (las tres funciones coinciden con el pseudocódigo: selection_sort con for (let i = 0; i < n - 1; i++) y for (let j = i + 1; j < n; j++), bubble_sort con la bandera swapped y if (!swapped) break —el if not swapped: break del pseudocódigo— con el bucle interior j < n - 1 - i, e insertion_sort con el while (j >= 0 && array[j] > key) literal del pseudocódigo, estricto y por tanto estable. El único intercambio es por desestructuración ([a, b] = [b, a]); no se invoca Array.prototype.sort. Divergencias idiomáticas aceptadas: orden in-place que devuelve la misma referencia —variante que la especificación permite— y null como indicador de fallo (representable en un array de JavaScript)) Tests y comandos / Tests and commands:

Verificación estática: npm run build (tsc --noEmit con strict: true, target: ES2022, module/moduleResolution: NodeNext) -> sin salida, sin errores ni warnings
npm test (jest --runInBand) -> PASS test/naive_sort.test.ts, 24 líneas ✓ <algorithm> should sort <caso> y Test Suites: 1 passed, 1 total, Tests: 24 passed, 24 total, Snapshots: 0 total (8 casos × 3 algoritmos = 24)
Contra-verificación en copia desechable (/tmp, ya eliminada): con una implementación de sonda la suite dio Tests: 24 passed, 24 total; invirtiendo result[j] < result[minIndex] por > en selection_sort -> ✕ selection_sort should sort an unsorted array (y tres más) con ● naive_sort › selection_sort should sort an unsorted array; revertido -> verde README(s) verificado(s) / README(s) verified: yes (typescript/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 45/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk) -> 46/49 (…, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk, TypeScript) Observaciones / Notes: Cuadragésima sexta implementación homologada de la Fase 1. No cierra la fase: faltan los demás lenguajes y los módulos restantes. El andamiaje usó el comando de la guía (✅ npm init -y) y después se configuró el paquete como foundations/numbers/: name: "typescript-naive_sort", private: true, scripts test: "jest --runInBand" y build: "tsc --noEmit", y devDependencies @types/jest ^29.5.14, jest ^29.7.0, ts-jest ^29.2.5, typescript ^5.8.3; tsconfig.json (strict, ES2022, NodeNext, types: ["jest"], include de src/ y test/) y jest.config.cjs (preset ts-jest, roots: [test], testMatch: **/*.test.ts) son los mismos que en numbers/. .gitignore con node_modules/, dist/, coverage/ y package-lock.json (verificado con git check-ignore -v node_modules/jest/package.json package-lock.json dist/x coverage/x -> los cuatro coinciden). Naming: los nombres snake_case de la especificación (selection_sort, bubble_sort, insertion_sort) son los que usa la clase Numbers del repositorio, así que no hubo adaptación; la suite los conserva en el nombre de cada test. Caso nulo incluido: un array de JavaScript admite null, así que el indicador de fallo es null (distinguible de []) y la suite cubre 8 casos (los 7 de la especificación más el nulo) = 24 tests; cada caso ordena una copia [...input] porque los algoritmos ordenan in-place (aislamiento). Limitación encontrada y resuelta en la suite: Jest 29 no admite mensaje en expect (Expect takes at most one argument.), así que el helper registra un test por caso y el mensaje del contrato (selection_sort should sort an unsorted array) es el nombre del test —mismo criterio ya documentado en el módulo ReScript—. Particularidades documentadas en el README: bucles for (let …) con cotas 0-based, intercambio por desestructuración y sin Array.prototype.sort. Ubicación desviada de la especificación: src/naive_sort.ts (solo cambia la extensión), test/naive_sort.test.ts (patrón .test.ts de jest.config.cjs, como en numbers/) y ausencia de run_tests.ts porque npm test ejecuta Jest. Los avisos de npm install (inflight, glob) son de dependencias transitivas de Jest. El submódulo está en la rama feat/algorithms/naive-sort. El índice de fase typescript/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-20 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): v Código verificado / Code verified: yes (la primera versión no compilaba: las tres funciones hacían mut array := array.clone(), redeclarando el parámetro con := en el mismo ámbito, y V lo rechaza con error: redefinition of 'array'; corregido renombrando el parámetro a arr y la copia mutable a result. Las tres funciones coinciden después con el pseudocódigo: selection_sort con for i in 0 .. n - 1 y for j in i + 1 .. n (rangos semiabiertos), bubble_sort con la bandera swapped y if !swapped { break } —el if not swapped: break del pseudocódigo— con el bucle interior 0 .. n - 1 - i, e insertion_sort con el for j >= 0 && result[j] > key literal del pseudocódigo, estricto y por tanto estable. El único intercambio es la asignación doble a, b = b, a; no se invoca sort. Divergencias idiomáticas aceptadas: reciben el array por valor, ordenan una copia mutable (arr.clone()) y devuelven un array nuevo —variante «in-place o copia ordenada» que la especificación permite—, y el caso nulo se omite porque []int es un tipo de valor y no admite null) Tests y comandos / Tests and commands:

Verificación estática: v test . compila el módulo y la suite sin warnings ni errores (la compilación es la verificación de V)
v test . (desde la raíz del módulo) -> ---- Testing..., OK 2.319 ms …/test/naive_sort_test.v y Summary for all V _test.v files: 1 passed, 1 total. Elapsed time: 3438 ms, on 1 job. Comptime: 3432 ms. Runtime: 2 ms. (el resumen cuenta archivos de test: 1 archivo con 3 funciones test_* × 7 casos = 21 aserciones)
Contra-verificación en copia desechable (/tmp, ya eliminada): con una implementación de sonda la suite dio 1 passed, 1 total; invirtiendo result[j] < result[min_index] por > en selection_sort -> FAIL con la línea del assert y el mensaje del contrato selection_sort should sort an unsorted array; revertido -> verde
v fmt -verify src/naive_sort.v test/naive_sort_test.v -> el único desvío es la ausencia de salto de línea final en src/naive_sort.v; los módulos ya homologados numbers/ y unit_test/calculator/ también están not vfmt'ed (3 y 1 errores de formato), así que es el estado preexistente del repositorio para V README(s) verificado(s) / README(s) verified: yes (v/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 46/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk, TypeScript) -> 47/49 (…, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk, TypeScript, V) Observaciones / Notes: Cuadragésima séptima implementación homologada de la Fase 1. No cierra la fase: faltan los dos lenguajes restantes (vala, zig). La estructura es manual (✍️ mkdir -p src test + v.mod en la guía) y sigue el patrón de foundations/numbers/: v.mod (Module { name: 'naive_sort' … }), src/naive_sort.v (module src con las 3 funciones pub fn), test/naive_sort_test.v (suite integrada) y .gitignore (ejecutables naive_sort/naive_sort.exe y objetos nativos *.out, *.o, *.so, *.dylib, *.dll; verificado con git check-ignore -v naive_sort.exe -> .gitignore:2:naive_sort.exe). La suite importa el módulo con import naive_sort.src, ruta que V resuelve por el nombre del directorio (una copia en /tmp con otro nombre de carpeta falla con cannot import module "naive_sort.src"). Naming: los nombres snake_case de la especificación (selection_sort, bubble_sort, insertion_sort) son los que usa numbers.v, así que no hubo adaptación; el parámetro es arr y la copia mutable result (V no permite redeclarar el parámetro). Caso nulo omitido: []int es un tipo de valor y no admite null, y los opcionales llegan en una fase posterior; se conservan los 7 casos de la especificación = 21 aserciones. Los arrays de V son valores, así que los fixtures no se contaminan aunque la función reordene su copia. Particularidades documentadas en el README: rangos semiabiertos (0 .. n - 1, 0 .. n - 1 - i), asignación doble para el intercambio, assert cond, 'mensaje' (V sí admite mensaje, a diferencia de Jest) y constantes vacías con tipo explícito ([]int{}). Ubicación desviada de la especificación: src/naive_sort.v (solo cambia la extensión), test/naive_sort_test.v (sufijo _test.v que V descubre) y ausencia de run_tests.v porque v test . es el runner. El submódulo está en la rama feat/algorithms/naive-sort. El índice de fase v/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-20 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): vala Código verificado / Code verified: yes (las tres funciones del namespace NaiveSort coinciden con el pseudocódigo: selection_sort con for (int i = 0; i < n - 1; i++) y for (int j = i + 1; j < n; j++), bubble_sort con la bandera swapped y if (!swapped) { break; } —el if not swapped: break del pseudocódigo— con el bucle interior j < n - 1 - i, e insertion_sort con el while (j >= 0 && arr[j] > key) literal del pseudocódigo, estricto y por tanto estable. Los intercambios usan una variable temp; no se invoca ninguna función de ordenamiento de GLib. Divergencias idiomáticas aceptadas: orden in-place que devuelve la misma referencia —variante que la especificación permite— y el caso nulo se omite porque int[] no admite null sin la anotación int[]?) Tests y comandos / Tests and commands:

Verificación estática: valac src/naive_sort.vala test/naive_sort_tests.vala --pkg glib-2.0 -o /tmp/vala-naive-sort-tests -> sin salida, sin warnings ni errores
/tmp/vala-naive-sort-tests -> TAP version 13, 1..3, # Start of naive_sort tests, ok 1 /naive_sort/selection_sort, ok 2 /naive_sort/bubble_sort, ok 3 /naive_sort/insertion_sort y # End of naive_sort tests (3 tests × 7 casos = 21 aserciones)
Contra-verificación en copia desechable (/tmp, ya eliminada): con una implementación de sonda la suite dio 1..3 con ok 1, ok 2, ok 3; invirtiendo arr[j] < arr[min_index] por > en selection_sort -> # selection_sort should sort an unsorted array (mensaje del contrato) y not ok /naive_sort/selection_sort - ERROR:…:check_case: code should not be reached; revertido -> verde
Comprobación de nulabilidad: valac avisa Argument 1: Cannot pass null to non-null parameter type al pasar null a un parámetro int[], evidencia de que el caso nulo no es representable sin int[]? README(s) verificado(s) / README(s) verified: yes (vala/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 47/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk, TypeScript, V) -> 48/49 (…, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk, TypeScript, V, Vala) Observaciones / Notes: Cuadragésima octava implementación homologada de la Fase 1. No cierra la fase: falta zig. La estructura es manual (✍️ mkdir -p src test en la guía) y sigue el patrón de foundations/numbers/: src/naive_sort.vala (namespace NaiveSort con las 3 funciones, declaradas static, es decir con visibilidad de archivo: el módulo se compila junto con la suite en una sola invocación de valac, que es el flujo documentado), test/naive_sort_tests.vala (GLib.Test) y .gitignore (binario naive_sort_tests y archivos generados por valac: *.c, *.h, *.vapi, *.o, *.a, *.so; verificado con git check-ignore -v naive_sort_tests src/naive_sort.vala.c test/naive_sort_tests.vala.c x.o x.vapi -> todos coinciden). La suite usa un delegate int[] SortFunc(int[] arr) para pasar la función a probar, un helper assert_sorts_all_cases(algorithm, sort) que recorre los 7 casos y un helper check_case por caso; main registra los 3 tests con Test.add_func y los ejecuta con Test.run() (salida TAP). Naming: los nombres snake_case de la especificación (selection_sort, bubble_sort, insertion_sort) son los que usa numbers.vala, así que no hubo adaptación. Caso nulo omitido: int[] no admite null sin int[]? (comprobado con valac, que avisa Cannot pass null to non-null parameter type), así que no es representable en la firma; se conservan los 7 casos de la especificación = 21 aserciones. Los arrays de Vala se pasan por referencia y los algoritmos ordenan in-place, así que la suite crea los fixtures como arrays locales en cada llamada al helper (aislamiento); además se evitaron fixtures const int[] porque su copia genera warnings de C (-Wdiscarded-qualifiers) al compilar con --pkg glib-2.0. GLib.Test no admite mensaje en assert, así que el mensaje del contrato se emite con Test.message + assert_not_reached(), que es lo que aparece en el reporte de fallo. Ubicación desviada de la especificación: src/naive_sort.vala (solo cambia la extensión), test/naive_sort_tests.vala (sufijo en plural, como recursive_tests.vala) y ausencia de run_tests.vala; el binario se compila en /tmp, fuera del repositorio. El submódulo está en la rama feat/algorithms/naive-sort. El índice de fase vala/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-20 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): zig Código verificado / Code verified: yes (la primera versión no compilaba: las tres funciones usaban for (i32 i = 0; i < n - 1; i += 1), el for de tres cláusulas de C, y zig lo rechaza con error: expected ',' after for operand en src/naive_sort.zig:23:12 —mismo error con zig build y con zig ast-check—; también aparecía j >= 0 && arr[j] > key con el operador &&, que no existe en Zig, e índices tipados como i32. Corregido con la forma idiomática: for (0..n - 1) |i| con for (i + 1..n) |j| en selection_sort y for (0..n - 1 - i) |j| en bubble_sort —el equivalente exacto de for j = 0 to n - 2 - i del pseudocódigo—, while (j > 0 and arr[j - 1] > key) : (j -= 1) en insertion_sort —equivalente del while j >= 0 and arr[j] > key con índices usize que no pueden volverse negativos—, operadores and/or e índices usize. Las tres funciones coinciden después con el pseudocódigo: selection_sort busca el mínimo con min_index y solo intercambia if (min_index != i); bubble_sort con la bandera swapped y if (!swapped) break; —el if not swapped: break del pseudocódigo—; e insertion_sort con la comparación estricta, que lo mantiene estable. Los intercambios usan una variable temp y no se invoca std.sort —solo aparece en el comentario de contrato del módulo— ni ninguna otra ayuda de ordenamiento de la biblioteca estándar. Divergencias idiomáticas aceptadas: orden in-place que devuelve el mismo slice —variante que la especificación permite— y el caso nulo se omite porque un slice []i32 no admite null sin ?[]i32) Tests y comandos / Tests and commands:

Verificación estática: zig build -> sin salida, sin warnings ni errores (compila el módulo de producción y la librería estática); zig build --summary all -> Build Summary: 3/3 steps succeeded, install cached y +- compile lib naive_sort Debug native cached 26ms MaxRSS:38M
zig build test --summary all (desde la raíz del módulo) -> Build Summary: 3/3 steps succeeded; 3/3 tests passed, test success, +- run test 3 pass (3 total) 6ms MaxRSS:4M y +- compile test Debug native cached 45ms MaxRSS:4M (3 tests Zig, uno por algoritmo, × 7 casos = 21 aserciones)
zig fmt --check build.zig src/naive_sort.zig test/naive_sort_test.zig -> sin salida (rc=0), sin desvíos de formato
Contra-verificación en copia desechable (/tmp/zprobe, ya eliminada, con .zig-cache y zig-out borrados): con una implementación de sonda la suite quedó en verde (rc=0); invirtiendo arr[j] < arr[min_index] por > en selection_sort -> error: 'naive_sort_test.test.selection_sort' failed: slices differ…, con run test 2 pass, 1 fail (3 total) y la línea del mensaje del contrato selection_sort should sort an unsorted array, salida rc=1; revertido -> verde
Comprobación de nulabilidad: un slice de Zig no admite null sin envolverlo en un opcional (?[]i32), así que el caso nulo no es representable en la firma pub fn <algoritmo>(arr: []i32) []i32; se conservan los 7 casos de la especificación
Artefactos ignorados: git check-ignore -v zig-out/lib/libnaive_sort.a .zig-cache/x naive_sort naive_sort.exe x.o x.a x.so x.dylib x.dll -> las diez rutas coinciden con .gitignore (líneas 1-10) README(s) verificado(s) / README(s) verified: yes (zig/core/algorithms/naive_sort/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.naive_sort 48/49 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, Common Lisp, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk, TypeScript, V, Vala) -> 49/49 (…, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk, TypeScript, V, Vala, Zig), con el estado de la tabla de la fase a ✅ Observaciones / Notes: Cuadragésima novena y última implementación homologada del módulo core.algorithms.naive_sort: con Zig quedan los 49 lenguajes. No cierra la fase: faltan los módulos 06-09, que siguen en 0/49, así que la Fase 1 continúa 🔄. La estructura es manual (✍️ mkdir -p src test en la guía) y sigue el patrón de foundations/numbers/ adoptado en el andamiaje de este módulo: build.zig (módulo de producción con b.createModule, b.addLibrary estática e b.installArtifact; módulo de tests con test_module.addImport("naive_sort", naive_sort_module), b.addTest y b.step("test", …)), src/naive_sort.zig (3 funciones pub fn) y test/naive_sort_test.zig (std.testing integrado). Naming: los nombres snake_case de la especificación (selection_sort, bubble_sort, insertion_sort) son los que usa src/numbers.zig, así que no hubo adaptación; la suite los conserva en el nombre de cada test. Caso nulo omitido: []i32 no admite null sin ?[]i32 (opcionales que llegan en una fase posterior), así que no hay indicador que comprobar; se conservan los 7 casos = 21 aserciones. Los slices son vistas sobre memoria mutable, así que la suite copia cada fixture en un búfer local [64]i32 con @memcpy antes de ordenarlo (aislamiento). expectEqualSlices no admite mensaje, así que el helper imprime el mensaje del contrato con std.debug.print("{s} should sort {s}", …) antes de devolver el error; esa línea aparece en el reporte de fallo. La suite usa una tabla cases de SortCase (descripción, entrada, salida esperada) y un único helper compartido assert_sorts_all_cases(algorithm, sort) que recibe un puntero de función *const fn ([]i32) []i32. A diferencia de foundations/numbers/, en este módulo src/ y test/ sí llevan comentarios (contrato, caso nulo y aislamiento). Ubicación desviada de la especificación: src/naive_sort.zig (solo cambia la extensión), test/naive_sort_test.zig (mismo nombre que la especificación) y ausencia de run_tests.zig porque zig build test --summary all es el runner. El submódulo está en la rama feat/algorithms/naive-sort. El índice de fase zig/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-20 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.naive_sort Lenguaje(s) / Language(s): php Código verificado / Code verified: yes (las tres funciones de la clase NaiveSort coinciden con el pseudocódigo: selectionSort busca el mínimo del tramo no ordenado con $minIndex y solo intercambia if ($minIndex !== $i); bubbleSort conserva la bandera $swapped con if (!$swapped) break; —el if not swapped: break del pseudocódigo— y el bucle interior for ($j = 0; $j < $n - $i - 1; $j++), equivalente exacto de for j = 0 to n - 2 - i; e insertionSort usa el while ($j >= 0 && $arr[$j] > $key) literal del pseudocódigo, estricto y por tanto estable. Los intercambios se hacen por desestructuración ([$a, $b] = [$b, $a]) y ninguna función invoca sort, rsort, asort, usort ni otra ayuda de ordenamiento de la biblioteca estándar —comprobado con un grep de esas funciones en src/NaiveSort.php—. Divergencias idiomáticas aceptadas: (1) los arrays de PHP son tipos de valor (copy-on-write), así que cada método ordena su propia copia y devuelve el array ordenado, la variante «copia ordenada» que la especificación permite (no se usa array &$arr); (2) el if n <= 1 / return arr del pseudocódigo no se escribe explícitamente porque las cotas de los bucles ya lo cubren: con $n = 0, $n - 1 es -1 y $i < -1 nunca se cumple, y con $n = 1 no hay iteraciones, con el mismo comportamiento observable; (3) los métodos usan camelCase (selectionSort) por la convención de PHP (PSR-12) frente al snake_case de la especificación; (4) el caso nulo se omite porque array no admite null sin la anotación ?array) Tests y comandos / Tests and commands:

Verificación estática: php -l src/NaiveSort.php y php -l test/NaiveSortTest.php -> No syntax errors detected in src/NaiveSort.php y No syntax errors detected in test/NaiveSortTest.php (sin warnings; el módulo no declara linter)
composer test (phpunit a través del script de Composer; PHPUnit 13.3.4 sobre PHP 8.5.10) -> ... 3 / 3 (100%), Time: 00:00.001, Memory: 18.00 MB y OK (3 tests, 21 assertions), con código de salida 0 (3 tests, uno por algoritmo, con los 7 casos cada uno = 21 aserciones)
Contra-verificación en copia desechable (/tmp/php-naive-final, ya eliminada): invirtiendo $arr[$j] < $arr[$minIndex] por > en selectionSort -> selection_sort should sort an unsorted array, FAILURES! Tests: 3, Assertions: 15, Failures: 1. y rc=1; restaurada -> OK (3 tests, 21 assertions)
Artefactos ignorados: git check-ignore -v vendor/autoload.php composer.lock .phpunit.cache/x .phpunit.result.cache -> las cuatro rutas coinciden con .gitignore (líneas 1-4) README(s) verificado(s) / README(s) verified: yes (php/core/algorithms/naive_sort/README.md), más los índices: php/core/algorithms/README.md (Nivel 2, creado en este cierre) y php/core/README.md y php/README.md (Nivel 1, con la fase, el módulo y el comando composer install && composer test) Cambio en ROADMAP.md / ROADMAP.md change: ninguno. docs/ROADMAP.md no menciona php: el resumen de progreso explica que los contadores X/49 cuentan los 49 submódulos registrados en .gitmodules, y php es el submódulo 50 (git config --file .gitmodules --get-regexp path | wc -l -> 50), por lo que añadirlo a la lista de lenguajes de core.algorithms.naive_sort (hoy ✅ 49/49 (Ada, …, Vala, Zig)) exigiría renumerar también el contador y la leyenda de todas las fases. Queda a decisión del autor cómo dar de alta php como quincuagésimo lenguaje antes de tocar los contadores. Observaciones / Notes: Primera implementación homologada del submódulo php (nuevo en .gitmodules, rama feat/algorithms/naive-sort). La estructura es manual (✍️ mkdir -p src test + composer require --dev phpunit/phpunit) y sigue el patrón ya homologado en foundations/numbers/ y foundations/unit_test/calculator/: composer.json (PHPUnit ^13.3 como dependencia de desarrollo, classmap de src/ y test/, script test: phpunit), phpunit.xml (bootstrap vendor/autoload.php y suite sobre test/) y .gitignore (/vendor/, composer.lock, .phpunit.cache/, .phpunit.result.cache). El módulo declara la clase NaiveSort desde el esqueleto, así que ya está en el classmap y añadir métodos no requiere composer dump-autoload. Naming: métodos en camelCase (convención de PHP), con los nombres snake_case de la especificación conservados en el mensaje del contrato de cada aserción (selection_sort should sort an unsorted array); PHPUnit admite mensaje como tercer argumento de assertSame, a diferencia de expectEqual de Zig o del assert de GLib. Caso nulo omitido: array no admite null sin ?array (equivalente a int[]? de Vala y a ?[]i32 de Zig), que llega en la fase de abstracción y persistencia; se conservan los 7 casos = 21 aserciones. Aislamiento: los arrays de PHP son tipos de valor, así que el helper recibe en cada caso una copia nueva de la constante CASES y ningún fixture compartido puede contaminarse. La suite usa constantes nombradas por caso, una tabla CASES (descripción -> entrada y salida esperada) y un único helper compartido assertSortsAllCases(callable $sort, string $algorithm). Ubicación desviada de la especificación: src/NaiveSort.php y test/NaiveSortTest.php en PascalCase (PSR-4: un archivo por clase) y ausencia de run_tests.php porque composer test ejecuta PHPUnit. Nota para el autor: las dos últimas líneas del comentario de cabecera de src/NaiveSort.php siguen diciendo que la implementación está pendiente y ya no aplican (no se han tocado por la regla de no modificar la implementación). El índice de fase php/core/algorithms/README.md se creó en este cierre.

Fecha / Date: 2026-09-26 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): ada Código verificado / Code verified: yes (ada/core/algorithms/data_structures_basics/src/data_structures_basics.ads y .adb; la suite pasa 4/4 y el acta del sprint está en docs/evidence/algorithms/data_structures_basics/ada.md, commit c4e0f9e) Tests y comandos / Tests and commands:

alr build en ada/core/algorithms/data_structures_basics -> Success: Build finished successfully in 0.40 seconds., con 8 avisos de estilo -gnatyM (línea larga) y 7 warnings (-gnatwk en cuatro punteros de trabajo, Removed_Value asignada y no leída, Failure y Result declaradas y no referenciadas); ninguno es error
alr -C tests run en ada/core/algorithms/data_structures_basics -> OK Node, OK LinkedList, OK Stack, OK Queue, Total Tests Run: 4, Successful Tests: 4, Failed Assertions: 0, Unexpected Errors: 0
Verificación estática: Ada no tiene verificador declarado en la columna 5 de data/languages.tsv, así que glot verify informa sin verificador para ada: se omite y sale 0; el acta lo registra como verify_exit=- README(s) verificado(s) / README(s) verified: yes (ada/core/algorithms/data_structures_basics/README.md, generado desde docs/README_Template.md con las trece secciones obligatorias) y los índices de Nivel 1 y Nivel 2 corregidos en el mismo cambio: ada/core/algorithms/README.md (nombres canónicos de los seis módulos de la fase y el módulo 06 añadido), ada/core/foundations/README.md, ada/core/README.md y ada/README.md Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 📋 0/50 -> 🔄 1/50 (Ada). La fase sigue abierta Observaciones / Notes: Primera implementación homologada del módulo 06. Adaptaciones declaradas en el README del módulo: Make como equivalente idiomático de init, Failure_Value = -1 como indicador natural, Delete/Pop/Dequeue que devuelven el resultado por parámetro out, subproyecto tests/ (plural) frente al test/ de la especificación y caso nulo no representable en un tipo privado. La estructura por niveles se fijó en docs/README_Template.md (Niveles 1 y 2 como índices) y se aplicó a los cuatro README de ada; los índices de ada arrastraban referencias a learning/, console_training/, gui_training/, microservices/, Dockerfile y Jenkinsfile, que ya no existen en el submódulo, y nombres de módulo desactualizados (data_structures, structures_apps). El cierre se hizo a mano: glot sigue declarando en su hoja de ruta que pointer abre una rama propia para el puntero, y el autor decidió no usarlo.

Fecha / Date: 2026-09-26 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): assembly Código verificado / Code verified: yes (assembly/core/algorithms/data_structures_basics/src/ — seis ficheros: el contrato data_structures_basics.inc, alloc.asm, node.asm, linked_list.asm, stack.asm y queue.asm; el acta está en docs/evidence/algorithms/data_structures_basics/assembly.md, commit e4914bf) Tests y comandos / Tests and commands:

make run en assembly/core/algorithms/data_structures_basics -> tests run 15, passed 15, failed 0 (los quince pasos de la especificación, uno por fila de sus tablas de casos)
Compilación limpia: make clean && make -> ensambla once ficheros y enlaza con ld -m elf_x86_64, sin un solo aviso de NASM
Contra-verificación (obligatoria): rompiendo node_init para que guarde 0 en vez del valor -> tests run 15, passed 13, failed 2, y fallan exactamente los dos casos de Node; revertido -> 15/15 y sin rastro de la sonda
Verificación estática: Assembly no tiene verificador declarado en la columna 5 de data/languages.tsv, así que glot verify informa sin verificador para assembly: se omite y sale 0; el acta lo registra como verify_exit=- README(s) verificado(s) / README(s) verified: yes (assembly/core/algorithms/data_structures_basics/README.md, generado desde docs/README_Template.md con las trece secciones obligatorias) y los índices de Nivel 2 y Nivel 1 corregidos en el mismo cambio: assembly/core/algorithms/README.md (nombres canónicos de los seis módulos de la fase, el 06 añadido, patrón común y compilación rápida), assembly/core/README.md (Fases -> Módulos, con los dos módulos de la fase 1) y assembly/README.md (faltaba core/algorithms/ en la tabla) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 1/50 (Ada) -> 🔄 2/50 (Ada, Assembly). La fase sigue abierta Observaciones / Notes: Segunda implementación homologada del módulo 06. Decisión de diseño que el contrato no cubría, declarada en el README: sin libc no hay malloc, así que el módulo trae su propio heap (src/alloc.asm, bump allocator sobre la syscall brk) en vez de enlazar libc o limitar la capacidad con un pool estático, que la especificación prohíbe. Adaptaciones declaradas: node_init/linked_list_init/stack_init/queue_init en lugar de init (en Assembly no hay espacios de nombres ni métodos), 0 como ausencia nativa en los punteros, FAILURE = -1 como indicador, delete devolviendo 1/-1 y caso nulo no representable. El reparto en seis ficheros de src/ sigue la convención de los dos módulos de Assembly ya homologados (numbers y naive_sort dividen en tres) y trajo dos cambios estructurales: el contrato pasó de .asm a .inc como cabecera compartida (dfcef95) y el Makefile añadió -I$(SRC_DIR)/ junto a -I$(TEST_DIR)/ (e4914bf). El runner test/run_tests.asm no lo generó el andamiaje: es la deuda del bloque B ya declarada (el runner se cae entre scaffold y suite), y se escribió a mano con el patrón de naive_sort. Corregido además que assembly/core/algorithms/README.md listaba data_structures con la especificación 06_Data_Structures y structures_apps con 07_Structures_Apps, nombres que no existen en el repositorio.

Fecha / Date: 2026-09-27T14:32:42-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): ballerina Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/ballerina.md, commit 4c5dfbe) Tests y comandos / Tests and commands:

bal test -> código 0 README(s) verificado(s) / README(s) verified: yes (ballerina/core/algorithms/data_structures_basics/README.md y ballerina/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 2/50 (Ada, Assembly) -> core.algorithms.data_structures_basics🔄 3/50 (Ada, Assembly, Ballerina) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-09-27 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): c Código verificado / Code verified: yes (c/core/algorithms/data_structures_basics/src/data_structures_basics.c e include/data_structures_basics.h; la suite pasa 4/4 con gcc -Wall -Wextra -std=c99 sin warnings) Tests y comandos / Tests and commands:

make clean && make test en c/core/algorithms/data_structures_basics -> gcc -Wall -Wextra -std=c99 -Iinclude (0 warnings, 0 errors); [====] Synthesis: Tested: 4 | Passing: 4 | Failing: 0 | Crashing: 0
Verificación estática: gcc -Wall -Wextra -std=c99 — sin warnings ni errores README(s) verificado(s) / README(s) verified: yes (c/core/algorithms/data_structures_basics/README.md, generado desde docs/README_Template.md con las secciones obligatorias) e índices corregidos: c/core/algorithms/README.md (estructura de directorios con data_structures_basics, tabla de módulos actualizada, patrón común y compilación rápida añadidos; nombres canónicos de los módulos pendientes corregidos de data_structures/structures_apps a data_structures_advanced), c/core/README.md (data_structures_basics añadido a la descripción de la fase) y c/README.md (core/algorithms/ añadido a la tabla de módulos y comandos de naive_sort y data_structures_basics añadidos al inicio rápido) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 3/50 (Ada, Assembly, Ballerina) -> core.algorithms.data_structures_basics 🔄 4/50 (Ada, Assembly, Ballerina, C). La fase sigue abierta. Observaciones / Notes: Cuarta implementación homologada del módulo 06. Adaptaciones idiomáticas declaradas en el README del módulo: node_init(Node*, int) en lugar del método Node.init(value) del pseudocódigo (C no tiene métodos; el prefijo de tipo es la convención de espacio de nombres), NULL como ausencia nativa de enlace, FAILURE_VALUE = -1 como indicador de fallo entero, linked_list_delete devolviendo 0/-1 en lugar del tipo booleano del pseudocódigo, malloc/free para gestión de memoria manual y layout include/ + src/ + test/ (sin run_tests.ext separado: Criterion descubre tests automáticamente). El índice de Nivel 2 c/core/algorithms/README.md también corregía los nombres de los módulos pendientes 06 y 07, que se listaban como data_structures y structures_apps en lugar de sus nombres canónicos data_structures_basics y data_structures_advanced.

Fecha / Date: 2026-09-30T18:06:49-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): cpp Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/cpp.md, commit d1d98d2) Tests y comandos / Tests and commands:

bazelisk test //... -> código 0 README(s) verificado(s) / README(s) verified: yes (cpp/core/algorithms/data_structures_basics/README.md y cpp/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 6/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL) -> core.algorithms.data_structures_basics 🔄 7/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL, C++) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-01T19:23:49-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): crystal Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/crystal.md, commit 2a71183) Tests y comandos / Tests and commands:

crystal spec -> código 0
crystal tool format --check src -> código 0 README(s) verificado(s) / README(s) verified: yes (crystal/core/algorithms/data_structures_basics/README.md y crystal/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 7/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL, C++) -> core.algorithms.data_structures_basics 🔄 8/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL, C++, Crystal) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-02T19:46:38-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): csharp Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/csharp.md, commit 5006702) Tests y comandos / Tests and commands:

dotnet test DataStructuresBasics.slnx -> código 0 README(s) verificado(s) / README(s) verified: yes (csharp/core/algorithms/data_structures_basics/README.md y csharp/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 8/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL, C++, Crystal) -> core.algorithms.data_structures_basics 🔄 9/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-02T22:51:15-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): d Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/d.md, commit 6652b39) Tests y comandos / Tests and commands:

dub test -> código 0 README(s) verificado(s) / README(s) verified: yes (d/core/algorithms/data_structures_basics/README.md y d/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 9/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal) -> core.algorithms.data_structures_basics 🔄 10/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-03T08:42:46-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): dart Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/dart.md, commit 1614ce8) Tests y comandos / Tests and commands:

dart test -> código 0
dart analyze -> código 0 README(s) verificado(s) / README(s) verified: yes (dart/core/algorithms/data_structures_basics/README.md y dart/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 10/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D) -> core.algorithms.data_structures_basics 🔄 11/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-03T13:34:54-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): elixir Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/elixir.md, commit 2d79670) Tests y comandos / Tests and commands:

mix test -> código 0
mix format --check-formatted -> código 0 README(s) verificado(s) / README(s) verified: yes (elixir/core/algorithms/data_structures_basics/README.md y elixir/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 11/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart) -> core.algorithms.data_structures_basics 🔄 12/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-03T19:21:48-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): elm Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/elm.md, commit 4075674) Tests y comandos / Tests and commands:

elm-test -> código 0 README(s) verificado(s) / README(s) verified: yes (elm/core/algorithms/data_structures_basics/README.md y elm/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 12/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir) -> core.algorithms.data_structures_basics 🔄 13/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-03T20:48:27-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): erlang Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/erlang.md, commit dc80601) Tests y comandos / Tests and commands:

rebar3 eunit -> código 0 README(s) verificado(s) / README(s) verified: yes (erlang/core/algorithms/data_structures_basics/README.md y erlang/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 13/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm) -> core.algorithms.data_structures_basics 🔄 14/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-03T21:22:39-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): forth Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/forth.md, commit 5b22a4a) Tests y comandos / Tests and commands:

cd test && gforth run-tests.forth -> código 0 README(s) verificado(s) / README(s) verified: yes (forth/core/algorithms/data_structures_basics/README.md y forth/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 14/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang) -> core.algorithms.data_structures_basics 🔄 15/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-04T17:57:56-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): fsharp Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/fsharp.md, commit 6a45159) Tests y comandos / Tests and commands:

dotnet test -> código 0 README(s) verificado(s) / README(s) verified: yes (fsharp/core/algorithms/data_structures_basics/README.md y fsharp/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 15/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth) -> core.algorithms.data_structures_basics 🔄 16/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-04T18:32:06-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): gleam Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/gleam.md, commit 847deae) Tests y comandos / Tests and commands:

gleam test -> código 0 README(s) verificado(s) / README(s) verified: yes (gleam/core/algorithms/data_structures_basics/README.md y gleam/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 16/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#) -> core.algorithms.data_structures_basics 🔄 17/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-04T23:45:20-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): go Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/go.md, commit 27be11c) Tests y comandos / Tests and commands:

go test ./... -> código 0
test -z "$(gofmt -l src)" -> código 0 README(s) verificado(s) / README(s) verified: yes (go/core/algorithms/data_structures_basics/README.md y go/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 17/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam) -> core.algorithms.data_structures_basics 🔄 18/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-05T09:10:33-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): grain Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/grain.md, commit 936a1e3) Tests y comandos / Tests and commands:

make test -> código 0 README(s) verificado(s) / README(s) verified: yes (grain/core/algorithms/data_structures_basics/README.md y grain/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 18/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go) -> core.algorithms.data_structures_basics 🔄 19/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-05T12:24:16-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): groovy Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/groovy.md, commit bd8827b) Tests y comandos / Tests and commands:

./gradlew test -> código 0 README(s) verificado(s) / README(s) verified: yes (groovy/core/algorithms/data_structures_basics/README.md y groovy/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 19/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain) -> core.algorithms.data_structures_basics 🔄 20/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-05T19:38:41-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): haskell Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/haskell.md, commit 2726c95) Tests y comandos / Tests and commands:

cabal test -> código 0 README(s) verificado(s) / README(s) verified: yes (haskell/core/algorithms/data_structures_basics/README.md y haskell/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 20/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy) -> core.algorithms.data_structures_basics 🔄 21/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-05T20:02:46-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): haxe Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/haxe.md, commit 8e4da7d) Tests y comandos / Tests and commands:

haxe build.hxml -> código 0 README(s) verificado(s) / README(s) verified: yes (haxe/core/algorithms/data_structures_basics/README.md y haxe/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 21/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell) -> core.algorithms.data_structures_basics 🔄 22/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-05T20:29:49-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): java Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/java.md, commit fd396e0) Tests y comandos / Tests and commands:

mvn test -> código 0 README(s) verificado(s) / README(s) verified: yes (java/core/algorithms/data_structures_basics/README.md y java/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 22/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe) -> core.algorithms.data_structures_basics 🔄 23/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-05T22:16:45-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): javascript Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/javascript.md, commit de01c36) Tests y comandos / Tests and commands:

npm test -> código 0 README(s) verificado(s) / README(s) verified: yes (javascript/core/algorithms/data_structures_basics/README.md y javascript/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 23/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java) -> core.algorithms.data_structures_basics 🔄 24/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-06T09:14:25-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): julia Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/julia.md, commit 4100ea9) Tests y comandos / Tests and commands:

julia --project=. test/run_tests.jl -> código 0
julia --project=. -e 'for f in filter(x->endswith(x,".jl"), readdir("src")); Meta.parse(read("src/$f", String)); end' -> código 0 README(s) verificado(s) / README(s) verified: yes (julia/core/algorithms/data_structures_basics/README.md y julia/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 24/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript) -> core.algorithms.data_structures_basics 🔄 25/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-06T18:18:16-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): kotlin Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/kotlin.md, commit 0f897a8) Tests y comandos / Tests and commands:

gradle test -> código 0 README(s) verificado(s) / README(s) verified: yes (kotlin/core/algorithms/data_structures_basics/README.md y kotlin/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 25/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia) -> core.algorithms.data_structures_basics 🔄 26/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-06T20:13:00-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): lua Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/lua.md, commit bd8bd7f) Tests y comandos / Tests and commands:

busted -> código 0 README(s) verificado(s) / README(s) verified: yes (lua/core/algorithms/data_structures_basics/README.md y lua/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 26/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin) -> core.algorithms.data_structures_basics 🔄 27/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-06T21:58:17-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): nim Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/nim.md, commit 3aafc9c) Tests y comandos / Tests and commands:

nimble test -> código 0
nim check src/data_structures_basics.nim -> código 0 README(s) verificado(s) / README(s) verified: yes (nim/core/algorithms/data_structures_basics/README.md y nim/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 27/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua) -> core.algorithms.data_structures_basics 🔄 28/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-07T11:36:02-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): ocaml Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/ocaml.md, commit f66e37e) Tests y comandos / Tests and commands:

dune runtest -> código 0 README(s) verificado(s) / README(s) verified: yes (ocaml/core/algorithms/data_structures_basics/README.md y ocaml/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 28/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim) -> core.algorithms.data_structures_basics 🔄 29/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-07T14:43:40-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): perl Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/perl.md, commit d2e8cd2) Tests y comandos / Tests and commands:

prove --ext=.pl test/ -> código 0
find lib -type f -name '*.p[lm]' -print0 | xargs -0 -r -n1 perl -Ilib -c -> código 0 README(s) verificado(s) / README(s) verified: yes (perl/core/algorithms/data_structures_basics/README.md y perl/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 29/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml) -> core.algorithms.data_structures_basics 🔄 30/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-07T16:34:28-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): php Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/php.md, commit 6f86fde) Tests y comandos / Tests and commands:

composer test -> código 0
php -l src/DataStructuresBasics.php -> código 0 README(s) verificado(s) / README(s) verified: yes (php/core/algorithms/data_structures_basics/README.md y php/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 30/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl) -> core.algorithms.data_structures_basics 🔄 31/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-07T17:14:11-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): prolog Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/prolog.md, commit 1d46d18) Tests y comandos / Tests and commands:

cd test && swipl -q -f data_structures_basics_tests.pl -t halt -> código 0 README(s) verificado(s) / README(s) verified: yes (prolog/core/algorithms/data_structures_basics/README.md y prolog/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 31/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP) -> core.algorithms.data_structures_basics 🔄 32/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-07T18:10:32-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): purescript Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/purescript.md, commit 7ca388a) Tests y comandos / Tests and commands:

spago test -> código 0 README(s) verificado(s) / README(s) verified: yes (purescript/core/algorithms/data_structures_basics/README.md y purescript/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 32/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog) -> core.algorithms.data_structures_basics 🔄 33/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-07T19:20:22-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): python Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/python.md, commit 558b949) Tests y comandos / Tests and commands:

pytest -> código 0
python3 -m compileall -q src -> código 0 README(s) verificado(s) / README(s) verified: yes (python/core/algorithms/data_structures_basics/README.md y python/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 33/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript) -> core.algorithms.data_structures_basics 🔄 34/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-07T21:35:25-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): r Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/r.md, commit d4a9df6) Tests y comandos / Tests and commands:

make test -> código 0
Rscript -e 'invisible(lapply(list.files("R", full.names=TRUE), parse))' -> código 0 README(s) verificado(s) / README(s) verified: yes (r/core/algorithms/data_structures_basics/README.md y r/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 34/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python) -> core.algorithms.data_structures_basics 🔄 35/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-08T22:43:34-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): racket Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/racket.md, commit 07657f0) Tests y comandos / Tests and commands:

raco test -x . -> código 0 README(s) verificado(s) / README(s) verified: yes (racket/core/algorithms/data_structures_basics/README.md y racket/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 35/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R) -> core.algorithms.data_structures_basics 🔄 36/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-09T12:48:35-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): raku Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/raku.md, commit 181540d) Tests y comandos / Tests and commands:

prove6 -l t/ -> código 0 README(s) verificado(s) / README(s) verified: yes (raku/core/algorithms/data_structures_basics/README.md y raku/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 36/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket) -> core.algorithms.data_structures_basics 🔄 37/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-09T14:48:10-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): rescript Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/rescript.md, commit 4c4c933) Tests y comandos / Tests and commands:

npm test -> código 0 README(s) verificado(s) / README(s) verified: yes (rescript/core/algorithms/data_structures_basics/README.md y rescript/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 37/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku) -> core.algorithms.data_structures_basics 🔄 38/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-09T16:09:45-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): rexx Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/rexx.md, commit 98710c6) Tests y comandos / Tests and commands:

rexx test/data_structures_basics_tests.rexx -> código 0 README(s) verificado(s) / README(s) verified: yes (rexx/core/algorithms/data_structures_basics/README.md y rexx/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 38/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript) -> core.algorithms.data_structures_basics 🔄 39/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-10T22:45:41-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): ruby Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/ruby.md, commit dd39701) Tests y comandos / Tests and commands:

bundle exec rspec -> código 0
ruby -c src/data_structures_basics.rb -> código 0 README(s) verificado(s) / README(s) verified: yes (ruby/core/algorithms/data_structures_basics/README.md y ruby/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 39/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX) -> core.algorithms.data_structures_basics 🔄 40/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-11T14:50:37-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): rust Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/rust.md, commit 5503d14) Tests y comandos / Tests and commands:

cargo test -> código 0
cargo fmt --check -> código 0 README(s) verificado(s) / README(s) verified: yes (rust/core/algorithms/data_structures_basics/README.md y rust/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 40/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby) -> core.algorithms.data_structures_basics 🔄 41/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-11T15:25:18-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): scala Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/scala.md, commit 60fe2bc) Tests y comandos / Tests and commands:

sbt -batch -no-colors test -> código 0 README(s) verificado(s) / README(s) verified: yes (scala/core/algorithms/data_structures_basics/README.md y scala/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 41/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust) -> core.algorithms.data_structures_basics 🔄 42/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-11T20:20:38-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): scheme Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/scheme.md, commit 635d975) Tests y comandos / Tests and commands:

cd test && guile --no-auto-compile -s data_structures_basics_tests_guile.scm -> código 0 README(s) verificado(s) / README(s) verified: yes (scheme/core/algorithms/data_structures_basics/README.md y scheme/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 42/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala) -> core.algorithms.data_structures_basics 🔄 43/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-12T10:35:29-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): swift Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/swift.md, commit 06fef90) Tests y comandos / Tests and commands:

swift test -> código 0 README(s) verificado(s) / README(s) verified: yes (swift/core/algorithms/data_structures_basics/README.md y swift/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 43/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme) -> core.algorithms.data_structures_basics 🔄 44/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-12T13:01:18-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): tcl-tk Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/tcl-tk.md, commit 25e13a6) Tests y comandos / Tests and commands:

cd test && TCLLIBPATH="$(cd ../src && pwd)" tclsh9.0 data_structures_basics.test -> código 0 README(s) verificado(s) / README(s) verified: yes (tcl-tk/core/algorithms/data_structures_basics/README.md y tcl-tk/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 44/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift) -> core.algorithms.data_structures_basics 🔄 45/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-12T13:40:56-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): typescript Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/typescript.md, commit 9cb2677) Tests y comandos / Tests and commands:

npm test -> código 0 README(s) verificado(s) / README(s) verified: yes (typescript/core/algorithms/data_structures_basics/README.md y typescript/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 45/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk) -> core.algorithms.data_structures_basics 🔄 46/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk, TypeScript) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-12T15:58:14-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): vala Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/vala.md, commit 8b8c564) Tests y comandos / Tests and commands:

valac src/data_structures_basics.vala test/data_structures_basics_test.vala --pkg glib-2.0 -o /tmp/data_structures_basics-tests && /tmp/data_structures_basics-tests -> código 0 README(s) verificado(s) / README(s) verified: yes (vala/core/algorithms/data_structures_basics/README.md y vala/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 46/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk, TypeScript) -> core.algorithms.data_structures_basics 🔄 47/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk, TypeScript, Vala) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-12T16:47:27-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): zig Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/zig.md, commit d4af5d0) Tests y comandos / Tests and commands:

zig build test -> código 0
zig fmt --check src -> código 0 README(s) verificado(s) / README(s) verified: yes (zig/core/algorithms/data_structures_basics/README.md y zig/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 47/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk, TypeScript, Vala) -> core.algorithms.data_structures_basics 🔄 48/50 (Ada, Assembly, Ballerina, C, C#, Clojure, COBOL, C++, Crystal, D, Dart, Elixir, Elm, Erlang, Forth, F#, Gleam, Go, Grain, Groovy, Haskell, Haxe, Java, JavaScript, Julia, Kotlin, Lua, Nim, OCaml, Perl, PHP, Prolog, PureScript, Python, R, Racket, Raku, ReScript, REXX, Ruby, Rust, Scala, Scheme, Swift, Tcl/Tk, TypeScript, Vala, Zig) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-12 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): common-lisp Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_basics/common-lisp.md, commit a9bdf0e, veredicto green; el módulo está en el main del submódulo) Tests y comandos / Tests and commands:

ros run --load run-tests.lisp --eval '(uiop:quit)' -> Running test suite DATA-STRUCTURES-BASICS-SUITE, Did 15 checks., Pass: 15 (100%), Fail: 0 ( 0%), código de salida 0 (los quince pasos de la especificación)
Verificación estática: common-lisp no tiene verificador declarado en la columna 5 de data/languages.tsv, así que el acta lo registra como verify_exit=- README(s) verificado(s) / README(s) verified: yes (common-lisp/core/algorithms/data_structures_basics/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 48/50 (Ada, …, TypeScript, Vala, Zig) -> 🔄 49/50 (Ada, …, COBOL, Common Lisp, C++, …, Vala, Zig) Observaciones / Notes: Registro tardío, escrito a mano el 2026-10-12 (no lo generó glot close): el módulo cerró el 2026-09-29 con acta verde y el puntero del monorepo se confirmó (a259b27), pero el contador del roadmap nunca recogió el lenguaje. Quedan dos pendientes abiertos en ese mismo contador: (1) v — su módulo está en el main del submódulo (core/algorithms/data_structures_basics/) pero el acta almacenada está en rojo (v fmt -verify src -> verify_exit=1, commit 24c577a, anterior a la normalización tests/ -> test/), así que no cumple el criterio de «finalizado» que el propio contador declara; y (2) prolog — está contado, pero su módulo vive solo en la rama feat/algorithms/data-structures-basics (publicada, acta verde 1d46d18) y el gitlink del monorepo (ed42ba7) apunta al tip de esa rama sin integrar en su main (69f1e9f).

Fecha / Date: 2026-10-12 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_basics Lenguaje(s) / Language(s): v Código verificado / Code verified: yes (corregido y verificado el 2026-10-12: el fuente pasa a src/data_structures_basics.v con module src —que es lo que exige el verificador declarado del catálogo, v fmt -verify src— y la suite conserva tests/, la carpeta que crea v init --lib) Tests y comandos / Tests and commands:

v fmt -verify src -> sin salida, código 0
v -shared -check src/data_structures_basics.v -> sin salida, código 0
v test . -> OK 3.209 ms …/tests/data_structures_basics_test.v, Summary for all V _test.v files: 1 passed, 1 total. Elapsed time: 3350 ms, on 1 job. Comptime: 3344 ms. Runtime: 3 ms., código 0 README(s) verificado(s) / README(s) verified: yes (v/core/algorithms/data_structures_basics/README.md con estructura, v.mod, comandos y salidas reales al día, y el índice de fase v/core/algorithms/README.md con el árbol y los casos) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_basics 🔄 49/50 (Ada, …, TypeScript, Vala, Zig) -> ✅ 50/50 (Ada, …, TypeScript, V, Vala, Zig) Observaciones / Notes: cierre del último lenguaje del módulo. Los defectos venían del andamiaje sin normalizar: el módulo quedó con data_structures_basics.v en la raíz y tests/ (forma cruda de v init --lib), v.mod con version: '0.0.1'/license: 'GNU' y la evidencia en rojo (v fmt -verify src no encontraba src/), así que no hubo commit de cierre y el contador no lo recogía. Corregido a mano: fuente a src/ con module src, import de la suite a data_structures_basics.src, v.mod a 0.1.0/MIT (patrón de numbers, calculator y naive_sort) y README + índice al día. Pendiente del autor: el acta almacenada (docs/evidence/algorithms/data_structures_basics/v.md, commit 24c577a) es anterior a la corrección y sigue en rojo —conviene regenerarla al confirmar el cierre— y los cambios del submódulo están sin confirmar.

Fecha / Date: 2026-10-24T22:13:20-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_advanced Lenguaje(s) / Language(s): ada Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_advanced/ada.md, commit 7b30147) Tests y comandos / Tests and commands:

alr -C tests run -> código 0 README(s) verificado(s) / README(s) verified: yes (ada/core/algorithms/data_structures_advanced/README.md y ada/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_advanced 📋 -> core.algorithms.data_structures_advanced 🔄 1/50 (Ada) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-26T21:36:42-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_advanced Lenguaje(s) / Language(s): assembly Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_advanced/assembly.md, commit 44398f7) Tests y comandos / Tests and commands:

make run -> código 0 README(s) verificado(s) / README(s) verified: yes (assembly/core/algorithms/data_structures_advanced/README.md y assembly/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_advanced 🔄 1/50 (Ada) -> core.algorithms.data_structures_advanced 🔄 2/50 (Ada, Assembly) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-26T22:38:22-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_advanced Lenguaje(s) / Language(s): ballerina Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_advanced/ballerina.md, commit a7195bc) Tests y comandos / Tests and commands:

bal test -> código 0 README(s) verificado(s) / README(s) verified: yes (ballerina/core/algorithms/data_structures_advanced/README.md y ballerina/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_advanced 🔄 2/50 (Ada, Assembly) -> core.algorithms.data_structures_advanced 🔄 3/50 (Ada, Assembly, Ballerina) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-27T21:46:13-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_advanced Lenguaje(s) / Language(s): c Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_advanced/c.md, commit 9687015) Tests y comandos / Tests and commands:

make test -> código 0 README(s) verificado(s) / README(s) verified: yes (c/core/algorithms/data_structures_advanced/README.md y c/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_advanced 🔄 3/50 (Ada, Assembly, Ballerina) -> core.algorithms.data_structures_advanced 🔄 4/50 (Ada, Assembly, Ballerina, C) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-28T16:15:06-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_advanced Lenguaje(s) / Language(s): clojure Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_advanced/clojure.md, commit 3742a93) Tests y comandos / Tests and commands:

clojure -T:build test -> código 0 README(s) verificado(s) / README(s) verified: yes (clojure/core/algorithms/data_structures_advanced/README.md y clojure/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_advanced 🔄 4/50 (Ada, Assembly, Ballerina, C) -> core.algorithms.data_structures_advanced 🔄 5/50 (Ada, Assembly, Ballerina, C, Clojure) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-10-30T20:05:29-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_advanced Lenguaje(s) / Language(s): cobol Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_advanced/cobol.md, commit f847d3d) Tests y comandos / Tests and commands:

make test -> código 0 README(s) verificado(s) / README(s) verified: yes (cobol/core/algorithms/data_structures_advanced/README.md y cobol/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_advanced 🔄 5/50 (Ada, Assembly, Ballerina, C, Clojure) -> core.algorithms.data_structures_advanced 🔄 6/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-11-03T22:22:56-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_advanced Lenguaje(s) / Language(s): common-lisp Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_advanced/common-lisp.md, commit e707bce) Tests y comandos / Tests and commands:

ros run --load run-tests.lisp --eval '(uiop:quit)' -> código 0 README(s) verificado(s) / README(s) verified: yes (common-lisp/core/algorithms/data_structures_advanced/README.md y common-lisp/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_advanced 🔄 6/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL) -> core.algorithms.data_structures_advanced 🔄 7/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL, Common Lisp) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-11-06T22:18:17-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_advanced Lenguaje(s) / Language(s): cpp Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_advanced/cpp.md, commit 92fc573) Tests y comandos / Tests and commands:

bazelisk test //... -> código 0 README(s) verificado(s) / README(s) verified: yes (cpp/core/algorithms/data_structures_advanced/README.md y cpp/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_advanced 🔄 7/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL, Common Lisp) -> core.algorithms.data_structures_advanced 🔄 8/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL, Common Lisp, C++) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.

Fecha / Date: 2026-11-08T20:48:19-06:00 Fase / Phase: core.algorithms Módulo(s) / Module(s): core.algorithms.data_structures_advanced Lenguaje(s) / Language(s): crystal Código verificado / Code verified: yes (acta de evidencia / evidence record: docs/evidence/algorithms/data_structures_advanced/crystal.md, commit 022dfa5) Tests y comandos / Tests and commands:

crystal spec -> código 0
crystal tool format --check src -> código 0 README(s) verificado(s) / README(s) verified: yes (crystal/core/algorithms/data_structures_advanced/README.md y crystal/core/algorithms/README.md) Cambio en ROADMAP.md / ROADMAP.md change: core.algorithms.data_structures_advanced 🔄 8/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL, Common Lisp, C++) -> core.algorithms.data_structures_advanced 🔄 9/50 (Ada, Assembly, Ballerina, C, Clojure, COBOL, Common Lisp, C++, Crystal) Observaciones / Notes: entrada escrita por glot close desde la evidencia del sprint. La revisión cualitativa (pseudocódigo, divergencias idiomáticas) no la comprueba el script, y el commit lo hace el autor.