Lenguaje Shik para tuberías REPL

Shik: Lenguaje minimalista para tuberías en terminal y REPL

Tareas como buscar cadenas en archivos o contar líneas en un proyecto suelen requerir encadenar utilidades con APIs inconsistentes. Bash te obliga a lidiar con [ -f ] vs [[ -f ]], grep -q vs grep -l, y comillas para espacios en nombres de archivos. Python dispersa las operaciones de archivos entre os, shutil y pathlib. Shells como Nushell se centran en datos estructurados, pero fallan en guiones concisos.

Shik es un lenguaje inspirado en Lisp/Haskell, diseñado para REPL y automatización. Su sintaxis gira en torno a la aplicación de funciones mediante espacios, tuberías con $>, y composición con #>.

Ejemplos: De Bash a Shik

Buscar archivos con "- links" y moverlos a topics/:

Bash: 5 líneas llenas de trampas con banderas de grep y dolores de cabeza con comillas.

Shik:```

file.glob :./* $>

list.filter file.is-file $>

list.filter (fn [f] file.read f $> string.has "- links") $>

list.iterate (file.move :topics)

Cuatro pasos de tubería, sin importaciones, sin comandos externos.

Contar líneas en archivos `.rs`:

file.glob :./src/*/.rs $>

list.map (file.read #> string.lines #> list.len) $>

list.sum $>

print

Las tuberías fluyen de izquierda a derecha, el currying simplifica la aplicación parcial.

## Diseño central: Lisp se encuentra con Haskell

Todo es una función. `+ 1 2`, `list.map`, `file.glob` — todos se invocan de la misma manera. Los espacios aplican funciones; no se necesitan paréntesis para argumentos simples.

Cuatro operadores clave:

1. Espacio: `f x`
2. `#>`: composición `f #> g` → `fn [x] g (f x)`
3. `$`: aplicación de baja precedencia `print $ + 1 2`
4. `$>`: tubería `x $> f`

Currying automático: `(+ 1)` se convierte en la función "sumar 1". Orden de argumentos: el primer argumento es el modificador fijo.

let lst [1 2 3 4]

lst $> list.map (+ 1) ; [2 3 4 5]

lst $> list.map (* 2) ; [2 4 6 8]

Aritmética uniforme, sin necesidad de `flip`.

## Hoja de trucos de sintaxis: 5 minutos para dominarlo

**Literales:**```
42                    ; número
"hello"             ; cadena
:hello               ; símbolo (sin espacios)
[1 2 3]              ; lista
{:name :Alice}       ; objeto
fn [arg] body        ; función

Variables:```

let name :Alice

let greet fn [name] "¡Hola, {name}!"

print $ greet name

set x (+ x 5) ; mutación

Interpolación de cadenas con `{expr}`. Los puntos forman parte de los nombres: `string.+`, `file.read`.

**Funciones integradas:** `file.`, `list.`, `string.`, `shell.` listas para usar. `help list.map` muestra la documentación en el REPL.

## Ergonomía en terminal

No hay declaraciones vs expresiones — todo es una expresión. Solo datos y funciones globales, sin clases/métodos. Prueba en REPL puro, sin flechas necesarias.

La tubería `$>` elimina la anidación:

**Sin tubería:** `print (list.sum (list.map ...))` — un lío.

**Con tubería:** los datos fluyen de izquierda a derecha, legibilidad lineal.

Ejemplos de currying con `let`:

let add-one (+ 1)

let files-with-links (fn [dir] file.glob dir $> list.filter (file.read #> string.has "- links"))

## Características clave

- Aplicación de funciones unificada minimiza el aprendizaje de sintaxis.
- Tubería `$>` y currying para cadenas de datos sin anidación.
- Integradas `file.`, `list.`, `string.` — sin importaciones.
- REPL primero: `help`, símbolos `:`, interpolación `{}`.
- Orden de argumentos: el primero es modificador para parciales fáciles.

— Editorial Team