Shik-Sprache für REPL-Pipelines

Shik: Minimalistische Sprache für Terminal-Pipelines und REPL

Aufgaben wie das Suchen von Strings in Dateien oder das Zählen von Zeilen in einem Projekt erfordern oft das Aneinanderreihen von Tools mit inkonsistenten APIs. Bash zwingt Sie, mit [ -f ] vs [[ -f ]], grep -q vs grep -l und Anführungszeichen für Leerzeichen in Dateinamen zu jonglieren. Python verteilt Dateioperationen auf os, shutil und pathlib. Shells wie Nushell setzen auf strukturierte Daten, scheitern aber an knappen Skripten.

Shik ist eine Lisp/Haskell-inspirierte Sprache, die speziell für REPL und Automatisierung entwickelt wurde. Ihre Syntax basiert auf Funktionsanwendung durch Leerzeichen, Pipelines mit $> und Komposition mit #>.

Beispiele: Vom Bash zum Shik

Dateien mit "- links" finden und nach topics/ verschieben:

Bash: 5 Zeilen voller grep-Flag-Fallen und Anführungsprobleme.

Shik:```

file.glob :./* $>

list.filter file.is-file $>

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

list.iterate (file.move :topics)

Vier Pipeline-Schritte, keine Imports, keine externen Befehle.

Zeilen in `.rs`-Dateien zählen:

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

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

list.sum $>

print

Pipelines leiten Daten von links nach rechts, Currying vereinfacht partielle Anwendungen.

## Kern-Design: Lisp trifft Haskell

Alles ist eine Funktion. `+ 1 2`, `list.map`, `file.glob` – alles wird gleich aufgerufen. Leerzeichen wenden Funktionen an; keine Klammern für einzelne Argumente nötig.

Vier Schlüsselsoperatoren:

1. Leerzeichen: `f x`
2. `#>`: Komposition `f #> g` → `fn [x] g (f x)`
3. `$`: niedrigprioritätige Anwendung `print $ + 1 2`
4. `$>`: Pipeline `x $> f`

Automatisches Currying: `(+ 1)` wird zur "addiere 1"-Funktion. Argumentreihenfolge: Erstes Argument ist der feste Modifikator.

let lst [1 2 3 4]

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

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

Einheitliche Arithmetik, kein `flip` nötig.

## Syntax-Übersicht: In 5 Minuten fit

**Literale:**```
42                    ; Zahl
"hello"             ; String
:hello               ; Symbol (keine Leerzeichen)
[1 2 3]              ; Liste
{:name :Alice}       ; Objekt
fn [arg] body        ; Funktion

Variablen:```

let name :Alice

let greet fn [name] "Hello, {name}!"

print $ greet name

set x (+ x 5) ; Mutation

String-Interpolation mit `{expr}`. Punkte gehören zu Namen: `string.+`, `file.read`.

**Built-ins:** `file.`, `list.`, `string.`, `shell.` sofort einsatzbereit. `help list.map` zeigt Docs im REPL.

## Terminal-Ergonomie

Keine Anweisungen vs. Ausdrücke – alles sind Ausdrücke. Nur Daten und globale Funktionen, keine Klassen/Methoden. Testen im reinen REPL, keine Pfeiltasten nötig.

Pipeline `$>` eliminiert Verschachtelung:

**Ohne Pipeline:** `print (list.sum (list.map ...))` – ein Chaos.

**Mit Pipeline:** Daten fließen von links nach rechts, lineare Lesbarkeit.

Currying-Beispiele mit `let`:

let add-one (+ 1)

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

## Wichtige Features

- Einheitliche Funktionsanwendung minimiert Syntax-Lernaufwand.
- Pipeline `$>` und Currying für verschachtelungsfreie Datenketten.
- Eingebautes `file.`, `list.`, `string.` – keine Imports.
- REPL zuerst: `help`, Symbole `:`, Interpolation `{}`.
- Argumentreihenfolge: Erstes ist Modifikator für einfache Partialen.

— Editorial Team