docs: params/output semántico en 506 funciones para composabilidad

Añade campos params y output al frontmatter YAML de las 506 funciones del registry.
Cada parámetro tiene descripción semántica (qué representa, unidades, rango típico)
y cada función describe qué produce su output. Permite a agentes razonar sobre
cadenas de composición (ej: prices → log_return → sharpe_ratio) sin leer código.

functions/core/all_slice.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: slice
+    desc: "slice de elementos a validar"
+  - name: predicate
+    desc: "función que evalúa cada elemento; retorna true si cumple la condición"
+output: "true si todos los elementos cumplen el predicado; false en caso contrario"
 tested: false
 tests: []
 test_file_path: ""

functions/core/any_slice.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: slice
+    desc: "slice de elementos a validar"
+  - name: predicate
+    desc: "función que evalúa cada elemento; retorna true si cumple la condición"
+output: "true si al menos un elemento cumple el predicado; false en caso contrario"
 tested: false
 tests: []
 test_file_path: ""

functions/core/chunk.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: xs
+    desc: "slice de elementos a dividir"
+  - name: size
+    desc: "tamaño de cada trozo; debe ser > 0 (entra en pánico si size <= 0)"
+output: "slice de slices, donde cada sub-slice contiene hasta 'size' elementos; el último puede contener menos"
 tested: false
 tests: []
 test_file_path: ""

functions/core/compose2.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: f2
+    desc: "segunda función a aplicar (derecha): B -> C"
+  - name: f1
+    desc: "primera función a aplicar (izquierda): A -> B"
+output: "función compuesta que aplica f1 después f2, equivalente a f2(f1(x))"
 tested: false
 tests: []
 test_file_path: ""

functions/core/const_func.md

@@ -14,6 +14,10 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: value
+    desc: "valor constante a retornar siempre"
+output: "función que ignora su argumento y siempre retorna el valor constante"
 tested: false
 tests: []
 test_file_path: ""

functions/core/curry2.md

@@ -14,6 +14,10 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: f
+    desc: "función de dos argumentos a currificar: (A, B) -> C"
+output: "función currificada que retorna una función parcial: A -> (B -> C)"
 tested: false
 tests: []
 test_file_path: ""

functions/core/detect_cycle.md

@@ -14,6 +14,22 @@ returns: []
 returns_optional: false
 error_type: "error_go_core"
 imports: ["database/sql"]
+params:
+  - name: conn
+    desc: "conexión abierta a base de datos SQLite"
+  - name: table
+    desc: "nombre de la tabla que almacena el grafo"
+  - name: fromCol
+    desc: "nombre de la columna que contiene el nodo origen de cada arista"
+  - name: toCol
+    desc: "nombre de la columna que contiene el nodo destino de cada arista"
+  - name: filterCol
+    desc: "nombre de columna opcional para filtrar aristas semánticas; si es vacío, se consideran todas las aristas"
+  - name: fromNode
+    desc: "nodo origen de la nueva arista a validar"
+  - name: toNode
+    desc: "nodo destino de la nueva arista a validar"
+output: "error si agregaría un ciclo; nil si no hay ciclo"
 tested: false
 tests: []
 test_file_path: ""

functions/core/drop.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: slice
+    desc: "slice del cual eliminar elementos del inicio"
+  - name: n
+    desc: "cantidad de elementos a eliminar desde el inicio"
+output: "nuevo slice con los primeros n elementos eliminados; si n >= len(slice), retorna slice vacío"
 tested: false
 tests: []
 test_file_path: ""

functions/core/filter_slice.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: xs
+    desc: "slice de elementos a filtrar"
+  - name: pred
+    desc: "función predicado que retorna true para elementos a incluir"
+output: "nuevo slice con solo los elementos que cumplen el predicado"
 tested: true
 tests: ["filtra pares", "slice vacio retorna vacio", "ningun match retorna vacio"]
 test_file_path: "functions/core/filter_slice_test.go"

functions/core/find.md

@@ -14,6 +14,12 @@ returns: [option_go_core]
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: slice
+    desc: "slice donde buscar"
+  - name: predicate
+    desc: "función que evalúa cada elemento; retorna true para el buscado"
+output: "Option[T] envolviendo el primer elemento que cumple, o None si ninguno cumple"
 tested: false
 tests: []
 test_file_path: ""

functions/core/find_index.md

@@ -14,6 +14,12 @@ returns: [option_go_core]
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: slice
+    desc: "slice donde buscar"
+  - name: predicate
+    desc: "función que evalúa cada elemento; retorna true para el buscado"
+output: "Option[int] envolviendo el índice del primer elemento que cumple, o None si ninguno cumple"
 tested: false
 tests: []
 test_file_path: ""

functions/core/flat_map_slice.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: slice
+    desc: "slice de elementos a transformar"
+  - name: f
+    desc: "función que transforma cada elemento en un slice de resultados"
+output: "slice aplandado con todos los resultados concatenados"
 tested: false
 tests: []
 test_file_path: ""

functions/core/flatten.md

@@ -14,6 +14,10 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: slices
+    desc: "slice de slices a aplanar"
+output: "slice único con todos los elementos concatenados preservando orden"
 tested: false
 tests: []
 test_file_path: ""

functions/core/flip.md

@@ -14,6 +14,10 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: f
+    desc: "función de dos argumentos a invertir: (A, B) -> C"
+output: "función con argumentos intercambiados: (B, A) -> C"
 tested: false
 tests: []
 test_file_path: ""

functions/core/generate_id.md

@@ -14,6 +14,14 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: name
+    desc: "nombre de la entidad en snake_case"
+  - name: lang
+    desc: "lenguaje: 'go', 'py', 'bash', 'ts'"
+  - name: domain
+    desc: "dominio de la función: 'core', 'finance', etc."
+output: "ID canonizado en formato 'name_lang_domain' convertido a minúsculas"
 tested: false
 tests: []
 test_file_path: ""

functions/core/group_by.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: slice
+    desc: "slice de elementos a agrupar"
+  - name: keyFn
+    desc: "función que extrae la clave de agrupación para cada elemento"
+output: "mapa donde cada clave única mapea a un slice de elementos con esa clave"
 tested: false
 tests: []
 test_file_path: ""

functions/core/identity.md

@@ -14,6 +14,10 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: x
+    desc: "valor a retornar sin modificación"
+output: "el mismo valor recibido como entrada"
 tested: false
 tests: []
 test_file_path: ""

functions/core/join_by_key.md

@@ -14,6 +14,16 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: left
+    desc: "slice izquierdo de map[string]any a unir"
+  - name: right
+    desc: "slice derecho de map[string]any a unir"
+  - name: key
+    desc: "nombre del campo común a usar como clave de unión"
+  - name: how
+    desc: "tipo de unión: 'inner', 'left', 'right', 'outer'"
+output: "slice de map[string]any con el resultado de la unión; campos duplicados del right se sufijan con '_right'"
 tested: true
 tests:
   - "Inner join solo matches"

functions/core/map_concurrent.md

@@ -14,6 +14,14 @@ returns: []
 returns_optional: false
 error_type: "error_go_core"
 imports: []
+params:
+  - name: xs
+    desc: "slice de elementos a procesar"
+  - name: fn
+    desc: "función a aplicar a cada elemento"
+  - name: workers
+    desc: "número de goroutines concurrentes; se ajusta a max(1, min(workers, len(xs)))"
+output: "slice de resultados en el mismo orden original que la entrada"
 tested: false
 tests: []
 test_file_path: ""

functions/core/map_slice.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: xs
+    desc: "slice de elementos a transformar"
+  - name: fn
+    desc: "función que transforma cada elemento de tipo T a tipo U"
+output: "nuevo slice de resultados transformados, mismo tamaño que entrada"
 tested: true
 tests: ["transforma enteros a strings", "slice vacio retorna vacio", "preserva orden"]
 test_file_path: "functions/core/map_slice_test.go"

functions/core/memoize.md

@@ -14,6 +14,10 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: fn
+    desc: "función pura a memorizar: K -> V; los resultados se cachean por clave"
+output: "función memoizada que retorna resultados en caché para claves ya calculadas; no es thread-safe"
 tested: false
 tests: []
 test_file_path: ""

functions/core/next_cron_time.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: [time]
+params:
+  - name: schedule
+    desc: "CronSchedule con listas de minutos, horas, días, etc. válidos"
+  - name: after
+    desc: "tiempo a partir del cual buscar la próxima ejecución"
+output: "time.Time con la próxima ejecución; zero time si no hay match dentro de 366 días"
 tested: true
 tests:
   - "0 * * * * desde :30 retorna la proxima hora en punto"

functions/core/parse_cron_expr.md

@@ -14,6 +14,10 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: [fmt, strconv, strings]
+params:
+  - name: expr
+    desc: "expresión cron de 5 campos: minuto hora día_mes mes día_semana; soporta *, rangos, listas, pasos y aliases"
+output: "CronSchedule con listas de valores válidos por campo; error si la expresión es inválida"
 tested: true
 tests:
   - "*/15 expande minutos a [0 15 30 45]"

functions/core/partial2.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: f
+    desc: "función de dos argumentos a aplicar parcialmente: (A, B) -> C"
+  - name: a
+    desc: "valor para fijar el primer argumento"
+output: "función parcial con primer argumento fijo: B -> C"
 tested: false
 tests: []
 test_file_path: ""

functions/core/partition.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: xs
+    desc: "slice a particionar"
+  - name: pred
+    desc: "función predicado que retorna true para la primera partición"
+output: "par de slices: (que cumplen predicado, que no cumplen); ambos preservan orden original"
 tested: false
 tests: []
 test_file_path: ""

functions/core/pipe2.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: f1
+    desc: "primera función a aplicar (izquierda): A -> B"
+  - name: f2
+    desc: "segunda función a aplicar (derecha): B -> C"
+output: "función compuesta que aplica f1 después f2, equivalente a f2(f1(x))"
 tested: false
 tests: []
 test_file_path: ""

functions/core/pipe3.md

@@ -14,6 +14,14 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: f1
+    desc: "primera función: A -> B"
+  - name: f2
+    desc: "segunda función: B -> C"
+  - name: f3
+    desc: "tercera función: C -> D"
+output: "función compuesta que aplica f1, luego f2, luego f3, equivalente a f3(f2(f1(x)))"
 tested: false
 tests: []
 test_file_path: ""

functions/core/pipeline.md

@@ -14,6 +14,10 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: fns
+    desc: "funciones variádicas de tipo T -> T a componer en secuencia"
+output: "función que aplica todas las funciones de izquierda a derecha; si no hay funciones, retorna la identidad"
 tested: false
 tests: []
 test_file_path: ""

functions/core/reduce.md

@@ -14,6 +14,14 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: slice
+    desc: "slice de elementos a reducir"
+  - name: initial
+    desc: "valor inicial del acumulador"
+  - name: f
+    desc: "función acumuladora que toma (acumulador, elemento) y retorna nuevo acumulador"
+output: "valor final del acumulador después de procesar todos los elementos"
 tested: false
 tests: []
 test_file_path: ""

functions/core/retry_with_backoff.md

@@ -14,6 +14,14 @@ returns: []
 returns_optional: false
 error_type: "error_go_core"
 imports: []
+params:
+  - name: fn
+    desc: "función impura a reintentar; retorna (resultado, error)"
+  - name: maxRetries
+    desc: "número máximo de reintentos después del intento inicial"
+  - name: baseDelay
+    desc: "delay base en time.Duration; cada reintento usa baseDelay * 2^i"
+output: "primer (resultado, nil) exitoso, o último error si se agotan los reintentos"
 tested: false
 tests: []
 test_file_path: ""

functions/core/rewrite_rule.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: ["regexp"]
+params:
+  - name: rule
+    desc: "expresión SQL con campos bare (sin prefijo) a reescribir como json_extract"
+  - name: jsonColumn
+    desc: "nombre de la columna JSON donde extraer los valores"
+output: "expresión SQL reescrita con json_extract para cada campo bare"
 tested: false
 tests: []
 test_file_path: ""

functions/core/take.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: slice
+    desc: "slice del cual tomar elementos del inicio"
+  - name: n
+    desc: "cantidad de elementos a tomar desde el inicio"
+output: "nuevo slice con los primeros n elementos; si n > len(slice), retorna el slice completo"
 tested: false
 tests: []
 test_file_path: ""

functions/core/uncurry2.md

@@ -14,6 +14,10 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: f
+    desc: "función currificada a descurrificar: A -> (B -> C)"
+output: "función normal de dos argumentos: (A, B) -> C"
 tested: false
 tests: []
 test_file_path: ""

functions/core/unique.md

@@ -14,6 +14,10 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: slice
+    desc: "slice del cual eliminar duplicados"
+output: "nuevo slice con elementos únicos preservando orden de primera aparición"
 tested: false
 tests: []
 test_file_path: ""

functions/core/validate_struct_fields.md

@@ -14,6 +14,12 @@ returns: []
 returns_optional: false
 error_type: ""
 imports: [fmt, regexp, strconv, strings]
+params:
+  - name: data
+    desc: "map[string]any con los campos a validar"
+  - name: rules
+    desc: "map[string]string donde cada clave es un campo y el valor es una lista de reglas (required, type, min/max, minlen/maxlen, oneof, pattern)"
+output: "tupla (válido: bool, errores: []string); si válido es true, errores está vacío"
 tested: true
 tests:
   - "campo required presente y ausente"

functions/core/zip.md

@@ -14,6 +14,12 @@ returns: [pair_go_core]
 returns_optional: false
 error_type: ""
 imports: []
+params:
+  - name: a
+    desc: "primer slice"
+  - name: b
+    desc: "segundo slice"
+output: "slice de pares (Pair[T, U]) emparejando elementos por índice; la longitud es min(len(a), len(b))"
 tested: false
 tests: []
 test_file_path: ""