Mode standalone

Sommaire

Catnip s'installe via pip install catnip-lang. Le binaire catnip est disponible immédiatement.

Usage

catnip script.cat              # Exécuter un script
catnip -c "x = 10; x * 2"     # Évaluer une expression
echo "2 + 3" | catnip --stdin  # Lire depuis stdin
catnip --version               # Version et build info
catnip -v script.cat           # Mode verbose (timings pipeline)

Options

catnip -o jit script.cat           # Activer le JIT
catnip -o tco:off script.cat       # Désactiver le TCO
catnip -o level:2 script.cat       # Niveau d'optimisation (0-3)
catnip -m numpy script.cat         # Charger un module Python
catnip -m math:m script.cat        # Module avec alias
catnip -x ast script.cat           # Interpréteur AST (au lieu de VM)
catnip --parsing 1 script.cat      # Niveau de parsing (0-3, voir ci-dessous)

Niveaux de parsing

--parsing permet d'inspecter les étapes du pipeline sans exécuter :

Niveau Sortie
0 Parse tree (AST Tree-sitter brut)
1 IR (après transformation, avant analyse sémantique)
2 IR exécutable (après analyse sémantique)
3 Exécution et résultat (défaut)

Mode benchmark

catnip bench script.cat        # 10 itérations par défaut
catnip bench 50 script.cat     # 50 itérations

Info runtime

catnip info

Scripts exécutables (shebang)

Ajouter #!/usr/bin/env catnip en première ligne et chmod +x :

#!/usr/bin/env catnip
# process.cat

import('sys')
input_file = sys.argv[1]
print('Processing ' + input_file)

chmod +x process.cat
./process.cat data.json
# => Processing data.json

sys.argv[0] contient le chemin du script, les arguments suivent à partir de sys.argv[1].

Hors mode script, sys.argv prend la forme que lui donne Python : ["-c"] suivi des arguments quand le code vient de -c, et [""] quand il vient de l'entrée standard ou de la REPL. La même liste est disponible sous le nom argv dans le scope global, sans importer sys.

Un programme embarqué (Catnip() dans une application Python) reçoit lui aussi [""] tant que l'hôte ne déclare pas d'argv : le module sys retombait sinon sur la ligne de commande du processus qui l'héberge, ce qui n'est pas une information que le code exécuté a demandée.

Si le nom du script entre en collision avec une sous-commande (format, lint, etc.), utiliser -- :

catnip -- format arg1 arg2

REPL

La REPL se lance avec catnip sans arguments (ou catnip repl).

Commandes

Toutes les commandes commencent par / :

Commande Description
/help Aide complète
/exit, /quit Quitter
/clear Effacer l'écran
/version Version et build
/history Historique (20 dernières entrées)
/load <file> Charger et exécuter un fichier .cat
/stats Statistiques d'exécution (variables, JIT)
/jit Toggle JIT
/verbose Toggle mode verbose (timings)
/debug Toggle mode debug (IR + bytecode)
/time <expr> Benchmarker une expression

Mode debug

Affiche l'IR optimisé et le bytecode sans exécuter :

▸ /debug
Debug mode: enabled (shows IR and bytecode)

▸ x = 10 + 20
Program(
    [
        Op {
            opcode: SetLocals,
            args: [
                Tuple(
                    [
                        Ref(
                            "x",
                            0,
                            1,
                        ),
                    ],
                ),
                Op {
                    opcode: Add,
                    args: [
                        Int(
                            10,
                        ),
                        Int(
                            20,
                        ),
                    ],
                    kwargs: {},
                    tail: false,
                    start_byte: 4,
                    end_byte: 11,
                },
                Bool(
                    false,
                ),
            ],
            kwargs: {},
            tail: false,
            start_byte: 0,
            end_byte: 11,
        },
    ],
)

=== Bytecode ===
Instructions:
    0: Instruction { op: LoadConst, arg: 0 }
    1: Instruction { op: LoadConst, arg: 1 }
    2: Instruction { op: Add, arg: 0 }
    3: Instruction { op: DupTop, arg: 0 }
    4: Instruction { op: DupTop, arg: 0 }
    5: Instruction { op: StoreLocal, arg: 0 }
    6: Instruction { op: StoreScope, arg: 0 }
    7: Instruction { op: Halt, arg: 0 }

Constants: 2 values
Names: ["x"]

Auto-complétion

Tab complète :

  • Commandes REPL (/he -> /help)
  • Keywords (wh -> while)
  • Builtins (pri -> print)
  • Variables définies
  • Méthodes après . (string/list/dict)
▸ x = "hello"
▸ x.<Tab>
capitalize  casefold  center  count  encode  endswith  find  format
index  isalnum  isalpha  join  lower  replace  split  strip  upper

Raccourcis clavier

Raccourci Action
Ctrl+D Quitter
Ctrl+C Annuler saisie
Up/Down Naviguer historique
Tab Auto-complétion

Historique persistant dans $XDG_STATE_HOME/catnip/repl_history (1000 entrées max, défaut ~/.local/state/catnip/repl_history).

Syntax highlighting

Coloration live en temps réel :

  • Keywords : cyan bold (if, while, for, match)
  • Constants : magenta bold (True, False, None)
  • Types : teal (dict, list, tuple, set)
  • Numbers : vert pâle
  • Strings : orange
  • Comments : gris
  • Operators : gris clair
  • Builtins : jaune (print, len, range)

Couverture du langage

Le mode standalone couvre 100% des features du langage Catnip : variables, fonctions, closures, structs, traits, pattern matching, broadcasting, pragmas, imports, mémoïsation, runtime introspection, extensions et module policies.