Langage Shik pour les pipelines REPL

Shik : langage minimaliste pour pipelines terminaux et REPL

Des tâches comme la recherche de chaînes dans des fichiers ou le comptage de lignes dans un projet nécessitent souvent de chaîner des utilitaires aux API incohérentes. Bash vous oblige à jongler entre [ -f ] et [[ -f ]], grep -q et grep -l, et les guillemets pour les espaces dans les noms de fichiers. Python disperse les opérations sur fichiers entre os, shutil et pathlib. Des shells comme Nushell misent sur les données structurées mais peinent sur les scripts concis.

Shik est un langage inspiré de Lisp/Haskell, conçu pour le REPL et l'automatisation. Sa syntaxe repose sur l'application de fonctions via les espaces, les pipelines avec $>, et la composition avec #>.

Exemples : du Bash à Shik

Trouver les fichiers contenant "- links" et les déplacer vers topics/ :

Bash : 5 lignes truffées de pièges avec les options de grep et les guillemets.

Shik :

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

Quatre étapes de pipeline, sans imports, sans commandes externes.

Comptage de lignes dans les fichiers .rs :

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

Les pipelines font circuler les données de gauche à droite, le curryfication simplifie l'application partielle.

Conception de base : Lisp rencontre Haskell

Tout est fonction. + 1 2, list.map, file.glob — tout s'invoque de la même façon. Les espaces appliquent les fonctions ; pas de parenthèses pour un seul argument.

Quatre opérateurs clés :

• Espace : f x
• #> : composition f #> g → fn [x] g (f x)
• $ : application de faible priorité print $ + 1 2
• $> : pipeline x $> f

Curryfication automatique : (+ 1) devient la fonction "ajouter 1". Ordre des arguments : le premier est le modificateur fixe.

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

Arithmétique uniforme, pas besoin de flip.

Fiche de syntaxe : Maîtrise en 5 minutes

Littéraux :

42                    ; nombre
"hello"             ; chaîne
:hello               ; symbole (sans espaces)
[1 2 3]              ; liste
{:name :Alice}       ; objet
fn [arg] body        ; fonction

Variables :

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

Interpolation de chaînes avec {expr}. Les points font partie des noms : string.+, file.read.

Fonctions intégrées : file., list., string., shell. prêtes à l'emploi. help list.map affiche la doc dans le REPL.

Ergonomie terminal

Pas de distinction entre instructions et expressions — tout est expression. Que des données et fonctions globales, pas de classes/méthodes. Tests en REPL pur, sans flèches.

Le pipeline $> élimine l'imbrication :

Sans pipeline : print (list.sum (list.map ...)) — un vrai casse-tête.

Avec pipeline : les données coulent de gauche à droite, lisibilité linéaire.

Exemples de curryfication avec let :

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

Fonctionnalités clés

• Application de fonctions unifiée pour minimiser l'apprentissage syntaxique.
• Pipeline $> et curryfication pour des chaînes de données sans imbrication.
• file., list., string. intégrés — sans imports.
• REPL en priorité : help, symboles :, interpolation {}.
• Ordre des arguments : le premier est modificateur pour des partiels faciles.

— Editorial Team