Shik jazyk pro REPL pipelines

Shik: minimalistický jazyk pro terminálové pipeliny a REPL

Terminálové úlohy jako hledání řetězců v souborech nebo počítání řádků v projektu vyžadují konvejnery z utilit s různými API. Bash nabízí [ -f ] vs [[ -f ]], grep -q vs grep -l, uvozovky pro mezery v názvech. Python rozptyluje souborové operace po os, shutil, pathlib. Shell jako Nushell se zaměřují na strukturovaná data, ale neřeší problém stručných skriptů.

Shik — Lisp/Haskell-podobný jazyk, zaměřený na REPL a automatizaci. Syntaxe je založena na aplikaci funkcí přes mezery, pipu $> a kompozici #>.

Příklady úloh: od bash k Shik

Hledání souborů s "- links" a přesunutí do topics/:

Bash: 5 řádků s nástrahami grep příznaků a uvozovek.

Shik:

file.glob :./* $>
  list.filter file.is-file $>
  list.filter (fn [f] file.read f $> string.has "- links") $>
  list.iterate (file.move :topics)

Čtyři kroky pipeline, bez importů, bez externích příkazů.

Počítání řádků v .rs-souborech:

file.glob :./src/**/*.rs $>
  list.map (file.read #> string.lines #> list.len) $>
  list.sum $>
  print

Pipe přenáší data zleva doprava, currying zjednodušuje částečnou aplikaci.

Základy designu: Lisp + Haskell

Vše — funkce. + 1 2, list.map, file.glob — volání podle jednotného pravidla. Mezera — aplikace, bez závorek pro jeden argument.

Čtyři operátory:

• Mezera: f x
• #>: kompozice f #> g → fn [x] g (f x)
• $: aplikace nízké priority print $ + 1 2
• $>: pipe x $> f

Automatické currying: (+ 1) — funkce "přičíst 1". Pořadí argumentů: první — fixovatelný modifikátor.

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

Jednotnost pro aritmetiku, bez flip.

Syntaxe: referenční příručka za 5 minut

Literály:

42                    ; číslo
"hello"             ; řetězec
:hello               ; symbol (bez mezer)
[1 2 3]              ; seznam
{:name :Alice}       ; objekt
fn [arg] tělo        ; funkce

Proměnné:

let name :Alice
let greet fn [name] "Hello, {name}!"
print $ greet name
set x (+ x 5)        ; mutace

Interpolace {výraz} v řetězcích. Tečka — část názvu: string.+, file.read.

Vestavěné moduly: file., list., string., shell. dostupné okamžitě. help list.map — dokumentace v REPL.

Ergonomie pro terminál

Žádné statements vs expressions — vše výrazy. Pouze data a globální funkce, bez tříd/metod. Testování v základním REPL bez šipek.

Pipe $> řeší vnořování:

Bez pipu: print (list.sum (list.map ...)) — zmatek.

S pipem: data proudí zleva doprava, čitelnost lineární.

Příklady currying s let:

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

Co je důležité

• Jednotný mechanismus aplikace funkcí minimalizuje učení syntaxe.
• Pipe $> a currying pro řetězce zpracování dat bez vnořování.
• Vestavěné file., list., string. bez importů.
• REPL-first design: help, symboly :, interpolace {}.
• Pořadí argumentů: první — modifikátor pro částečnou aplikaci.

— Editorial Team