Langage VVL

Tout est commande entre crochets

Une seule règle de syntaxe — [commande args…] — se décline partout : un calcul, une classe, un appel réseau, une requête LLM. Le code est une donnée : une liste s'évalue, ou se cite avec le backtick pour être manipulée comme un arbre syntaxique.

# Prefix form [command args…] — eager evaluation, innermost first
[print [+ 1 2 3]]          # → 6

# Variables ($), assignment (=), sugared infix arithmetic (…)
$prix = 100
$ttc  = ($prix * 1.20)          # → 120.0

# Quasiquote (backtick) = literal data; unquote (,) injects a value
$n = 5
`[1 ,$n ,[+ 1 2]]            # → [1 5 3]

# String interpolation: ${ VVL expression }
$msg = "n*n = ${[* $n $n]}"     # → "n*n = 25"

# Dotted accessors, chainable
$s = "  42  "
$s.trim.int                     # → 42

# Lambda (params → $__name) + map / pmap (parallel)
$double = [lambda [x] [* $__x 2]]
[map $double `[1 2 3 4]]          # → [2 4 6 8]
[pmap $extract $documents]      # N LLM calls in parallel

Quatre rôles, zéro pipeline

Dans VVL, le modèle de langage n'est pas un service externe qu'on appelle : il acquiert un contrat d'interface stable, au même titre que + ou ==. Il endosse quatre rôles, sans aucun code de plomberie entre eux.

[§ "chat"] == [§ "félin"]   # → 1
[§ "voiture"] + [§ "électrique"]
# → electric car (concept)

$fn = ($orders @ [§ "total_amount > 1000"])
[filter $fn $orders]   # local lambda, 0 LLM

$soleil = [@ "Soleil"]
$soleil.masse_kg     # → 1.989e30
($soleil ~~ "Étoile")  # → ~0.95

[§§ "consommation BMW Série 3 diesel 2024 ?"] # → ~5.1

[generic "masse de @{Saturne} ?"]
[get-mass-kg-of-concept "Jupiter"] # reusable

Un seul modèle de langage, quatre rôles distincts, zéro pipeline d'intégration. C'est ce qui fait de VVL un langage neuro-symbolique — et non un wrapper d'API.

Les vingt opérateurs sémantiques

Activés par l'opérande [§ "…"], ce sont les mêmes opérateurs que sur les nombres — c'est le type de l'opérande qui les fait basculer. Quatre familles, plus @.

Distinction fine : la projection / extrait une dimension déjà contenue dans la description ; la propriété % interroge la connaissance générale du LLM. Les résultats sémantiques se composent comme de l'arithmétique. Projetée sur une échelle ([§ ["bas" "moyen" "haut"]]), / rend un score : une position calibrée avec sa confiance.

Décider vite, raisonner si besoin

Avec [semanticMode "jev"], les décisions typées passent d'abord par Jev (TypeSafe AI) : un modèle qui ne rédige pas mais tranche — oui/non, choix, position sur une échelle — avec une confiance calibrée, en ~0,4 s. S'il hésite (confiance sous le seuil, 0,8 par défaut), le LLM reprend la main. Même syntaxe, même cache ; chaque décision est tracée dans semantic.log (onglet Semantic de :log).

[semanticMode "jev"]
[§ "a trumpet"] == [§ "a refrigerator"]         # → 0   (Jev, 0.4 s)
[match [§ $ticket]
    [§ "Payments, refunds"]  "billing"
    [§ "Bugs, outages"]      "technical"
    "escalade"]                                   # branch chosen by meaning
([§ $review] / [§ ["calm" "annoyed" "angry"]])   # → <approx: 1.99 [high]>
[fuzzy:degree [§ $mail] "spam"]                  # → 0.98

Le coût de l'IA paie une fois

Comment un système probabiliste devient-il aussi fiable qu'un opérateur natif ? Par quatre garanties intégrées au moteur — pas laissées au développeur : (1) typage de sortie automatique (on ne parse jamais une chaîne), (2) cache déterministe persistant sur disque — même expression, même résultat dans toutes les sessions, coût API → 0 et tests reproductibles, (3) retry validé jusqu'à succès, (4) spécifications XML few-shot. Sans le typage il faudrait parser ; sans le cache la latence serait prohibitive ; sans le retry la moindre variation du modèle casserait le programme. C'est l'ensemble qui distingue VVL d'un simple wrapper.

Du neuronal au raisonnement garanti

Le même langage embarque le versant symbolique : raisonnement déductif garanti, schémas typés et optimisation prouvée. Les concepts réifiés deviennent les opérandes de cette algèbre — c'est le pont neuro-symbolique.

Un état qui se prouve et se rejoue

Un [keyword] dont le [contract] nomme un registre devient un smart contract : chaque appel est une transaction, inscrite dans un bloc chaîné et signé. Les conditions du contrat se prouvent avant l'exécution, se vérifient à chaque appel, et l'historique entier se rejoue — le tout dans le langage, sans blockchain externe.

[keyword transfer
    [contract
        [args from to [amount :type Integer :min 1]]
        [ledger bank]
        [state [src "account:{from}" :required] [dst "account:{to}" :required]]
        [require "amount <= src"]
        [ensure  "src + dst = old(src) + old(dst)"]]
    [do [state:put src ([state:get src] - @3)]
        [state:put dst ([state:get dst] + @3)]]]

[contract:verify transfer].status        # → "proved"   (for every state)
[transfer "alice" "bob" 30]              # → one signed block
[transfer "alice" "bob" 500]             # → refused, nothing written
[ledger:verify bank].ok                  # → 1   (chain, signatures, full replay)

Interprété, compilé, puis distribué

Le même code passe de l'interpréteur à une machine virtuelle native, puis à plusieurs machines — sans être réécrit. Ce qui décide n'est pas un réglage, mais une propriété vérifiable du code : sa pureté.

VVL face à Python + LangChain

Un serveur IA unique, piloté par un langage dont le paradigme est conçu pour lui. C'est la différence entre intégrer l'IA et programmer avec elle.