REPL Interactive

La REPL Catnip utilise une implémentation Rust native (catnip-repl) en binaire standalone.

La REPL s'inscrit dans la tradition Lisp (lecture/évaluation/affichage). Dialogue direct avec le runtime: latence humaine, réponse machine.

Architecture REPL

Catnip fournit deux modes REPL selon le contexte :

REPL Rust (mode par défaut)

Binaire standalone catnip-repl implémenté en Rust pur :

• Rapide : startup instantané, exécution native
• Standalone : aucune dépendance Python runtime
• Optimisé : VM bytecode + JIT intégré
• Source : catnip_rs/src/bin/repl.rs

Utilisé automatiquement pour code Catnip pur.

REPL Python (minimal)

Wrapper léger MinimalREPL pour intégration Python (-f/--feature) :

• Contexte Python : accès aux modules chargés (-f math, etc.)
• Pipeline complet : parsing → semantic → execution Python
• Source : catnip/repl/minimal.py

Activé automatiquement si catnip -f module ou catnip repl -f module.

Lancement

# REPL Rust (par défaut)
catnip              # Mode interactif rapide
catnip -v           # Mode verbeux

# REPL Python (avec features)
catnip -f math      # Charge module Python, REPL Python
catnip -f ./api.py:api -f numpy:np  # Multi-modules

# Mode pipe (non-interactif)
echo "2+3" | catnip

Commandes REPL

Les commandes commencent par / :

Raccourcis clavier

REPL Rust (par défaut)

REPL Python (minimal)

La REPL Python minimal offre une interface simplifiée :

Pas d'auto-complétion ni de recherche historique avancée - focus sur compatibilité features Python.

Auto-complétion (REPL Rust)

Tab complète :

• Mots-cles du langage (if, while, match, etc.)
• Variables définies dans le contexte
• Fonctions builtin (print, len, range, etc.)
• Commandes REPL (/help, /exit, etc.)

Recherche historique (REPL Rust)

L'historique est persistant dans ~/.catnip_history (par défaut).

Multiline

La REPL détecte automatiquement les expressions multilignes :

• Délimiteurs non fermés ({, (, [)
• Opérateurs en fin de ligne (+, -, *, etc.)
• Mots-clés de contrôle (if, while, for, etc.)

Alt+Enter ou Ctrl+J force une nouvelle ligne même si l'expression semble complète.

▸ f = (x) => {
▹   x * 2
▹ }
▸ f(21)
42

Affichage des résultats

La REPL affiche automatiquement le résultat de chaque expression évaluée, y compris None :

▸ 42
42

▸ "hello"
hello

▸ None
None

Comportement (différent de Python) :

• Toutes les valeurs sont affichées, y compris None
• Clarté maximale en développement : aucun résultat n'est silencieux

Rationale : La REPL est un outil de développement. Afficher explicitement None évite toute ambiguïté sur le retour d'une expression (erreur vs None vs pas de retour).

Comparaison avec Python :

# Python REPL
>>> None
>>>             # Pas d'affichage

# Catnip REPL
▸ None
None            # Affichage explicite

Choix de REPL

Le CLI détecte automatiquement quelle REPL utiliser :

# REPL Rust (standalone)
catnip                    # Aucune feature → REPL Rust
catnip -o jit script.cat  # Pas de -f → REPL Rust si erreur

# REPL Python (wrapper)
catnip -f math            # -f présent → REPL Python
catnip -f ./api.py:api    # idem

Règle : Présence de -f/--feature déclenche REPL Python (accès contexte modules). Sinon, REPL Rust (standalone).

Erreur REPL manquante

Si catnip-repl n'est pas disponible :

Error: Rust REPL 'catnip-repl' not found in PATH
Install it with: make compile

Solution : recompiler le projet pour générer le binaire REPL :

make compile
# ou
make setup