{"id":2016,"date":"2026-03-20T17:31:37","date_gmt":"2026-03-20T16:31:37","guid":{"rendered":"https:\/\/coding4phone.com\/?p=2016"},"modified":"2026-03-20T17:31:39","modified_gmt":"2026-03-20T16:31:39","slug":"affectation-dynamique-de-variables-dans-mogwai","status":"publish","type":"post","link":"https:\/\/coding4phone.com\/?p=2016","title":{"rendered":"Affectation dynamique de variables dans MOGWAI"},"content":{"rendered":"\n

Sans eval, sans dictionnaire \u2014 juste la stack.<\/em><\/p>\n\n\n\n

\n

S\u00e9rie<\/strong> : MOGWAI<\/a> Deep Dive \u00b7 v8.3 \u00b7 coding4phone.com<\/p>\n<\/blockquote>\n\n\n\n

\n\n\n\n

La plupart des langages de script qui supportent le nommage dynamique de variables s’appuient sur eval<\/code> \u2014 un outil brutal qui ex\u00e9cute une cha\u00eene arbitraire comme du code. \u00c7a fonctionne, mais c’est opaque, souvent risqu\u00e9, et philosophiquement incompatible avec un syst\u00e8me de types coh\u00e9rent. D’autres langages vous poussent vers des dictionnaires ou de la r\u00e9flexion, au prix de verbosit\u00e9 et d’indirection.<\/p>\n\n\n\n

MOGWAI<\/a> prend une voie diff\u00e9rente. Parce que c’est un langage RPN orient\u00e9 stack, donn\u00e9es et code coexistent naturellement sur la pile<\/strong> \u2014 et le nommage dynamique devient une composition propre de trois petites primitives. Pas de magie. Pas d’\u00e9chappatoire. Juste la stack, qui fait son travail.<\/p>\n\n\n\n

\n\n\n\n

Le pattern en un coup d’\u0153il<\/h2>\n\n\n\n

Voici un exemple concret : cr\u00e9er 1 000 variables nomm\u00e9es $V1<\/code> \u00e0 $V1000<\/code>, chacune contenant un entier al\u00e9atoire entre 0 et 99.<\/p>\n\n\n\n

1 1000 for 'i' do {
    rand 100 * ->int
    -> { ! \"$V\" i + ->name }
}<\/pre>\n\n\n\n
D\u00e9cortiquons cela \u00e9tape par \u00e9tape.<\/p>\n\n\n\n
\n\n\n\n
Ex\u00e9cution pas \u00e0 pas<\/h2>\n\n\n\n
1 \u2014 Produire la valeur<\/h3>\n\n\n\n
rand 100 * ->int<\/pre>\n\n\n\n
\u00c9tape<\/th>Stack<\/th>Note<\/th><\/tr><\/thead>
rand<\/code><\/td>0.731\u2026<\/code><\/td>float \u2208 [0, 1[<\/td><\/tr>
100 *<\/code><\/td>73.1\u2026<\/code><\/td>mis \u00e0 l’\u00e9chelle [0, 100[<\/td><\/tr>
->int<\/code><\/td>73<\/code><\/td>entier \u2208 [0, 99]<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Rien de surprenant \u2014 une s\u00e9quence RPN classique qui laisse l’entier al\u00e9atoire sur la stack.<\/p>\n\n\n\n
\n\n\n\n
2 \u2014 Construire le nom de variable<\/h3>\n\n\n\n
{ ! \"$V\" i + ->name }<\/pre>\n\n\n\n
C’est le c\u0153ur du pattern. L’op\u00e9rateur !<\/code><\/strong> en t\u00eate du bloc demande \u00e0 MOGWAI<\/a> d’auto-\u00e9valuer<\/em> le bloc imm\u00e9diatement, au lieu de le pousser sur la stack comme un objet appelable. Le moteur ex\u00e9cute donc le corps du bloc en ligne :<\/p>\n\n\n\n
\u00c9tape<\/th>Stack<\/th>Note<\/th><\/tr><\/thead>
\"$V\"<\/code><\/td>\"$V\"<\/code><\/td>une simple cha\u00eene<\/td><\/tr>
i<\/code><\/td>\"$V\" 5<\/code><\/td>compteur de boucle<\/td><\/tr>
+<\/code><\/td>\"$V5\"<\/code><\/td>concat\u00e9nation de cha\u00eenes<\/td><\/tr>
->name<\/code><\/td>'$V5'<\/code><\/td>cha\u00eene \u2192 nom de variable<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
La transition cl\u00e9 est ->name<\/code><\/strong> : elle convertit la cha\u00eene \"$V5\"<\/code> \u2014 une donn\u00e9e \u2014 en le nom '$V5'<\/code> \u2014 une r\u00e9f\u00e9rence symbolique. Ce sont deux types distincts dans MOGWAI<\/a>. Pas de coercition implicite, pas de surprise : on franchit la fronti\u00e8re explicitement, d\u00e9lib\u00e9r\u00e9ment.<\/p>\n\n\n\n
\n\n\n\n
3 \u2014 L’affectation<\/h3>\n\n\n\n
-><\/pre>\n\n\n\n
Dans MOGWAI<\/a>, l’op\u00e9rateur -><\/code> est du sucre syntaxique pour STO<\/code>. Il d\u00e9pile un nom au sommet de la stack et la valeur juste en dessous, et stocke la valeur sous ce nom. \u00c0 ce stade la stack contient :<\/p>\n\n\n\n
Moment<\/th>Stack<\/th>Note<\/th><\/tr><\/thead>
avant -><\/code><\/td>73 '$V5'<\/code><\/td>valeur puis nom, nom au sommet<\/td><\/tr>
apr\u00e8s -><\/code><\/td>(vide)<\/em><\/td>73 stock\u00e9 dans $V5<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Ce qui est \u00e9quivalent \u00e0 : 73 '$V5' STO<\/code>. La stack est propre, la variable existe, on passe \u00e0 l’it\u00e9ration suivante.<\/p>\n\n\n\n
\n\n\n\n
Pourquoi c’est important<\/h2>\n\n\n\n
Dans de nombreux langages, le nommage dynamique de variables oblige \u00e0 recourir \u00e0 un \u00e9chappatoire. Comparons :<\/p>\n\n\n\n
Autres langages<\/strong><\/p>\n\n\n\n
eval(f\"V{i} = {val}\")   # Python \u2014 risqu\u00e9, opaque

# ou contournement par dictionnaire :
d = {}
d[f\"V{i}\"] = val        # indirect, plus vraiment des variables<\/pre>\n\n\n\n
MOGWAI<\/a><\/strong><\/p>\n\n\n\n
val -> { ! \"$V\" i + ->name }<\/pre>\n\n\n\n
eval<\/code> est puissant mais dangereux \u2014 il ex\u00e9cute du code arbitraire, court-circuite toute analyse statique et est impossible \u00e0 raisonner formellement. Le contournement par dictionnaire est s\u00fbr mais indirect : on ne travaille plus vraiment avec des variables, on compense leur absence.<\/p>\n\n\n\n
L’approche MOGWAI<\/a> est explicite<\/strong> et composable<\/strong> : on construit le nom comme une donn\u00e9e, on le promeus en r\u00e9f\u00e9rence symbolique avec ->name<\/code>, et on le passe \u00e0 -><\/code> comme n’importe quel autre nom. La stack est le seul medium. Chaque \u00e9tape est visible, tra\u00e7able, et debuggable dans MOGWAI Studio.<\/p>\n\n\n\n
\n
Insight cl\u00e9<\/strong><\/p>\n\n\n\n
Ce pattern est une expression de l’homo\u00efconicit\u00e9 sur la stack<\/strong>. Donn\u00e9es et noms coexistent dans le m\u00eame espace. La fronti\u00e8re entre eux n’est pas dissoute \u2014 elle est franchissable d\u00e9lib\u00e9r\u00e9ment, une primitive \u00e0 la fois. C’est ce que MOGWAI<\/a> h\u00e9rite de la tradition HP RPL.<\/p>\n<\/blockquote>\n\n\n\n
\n\n\n\n
Les trois primitives<\/h2>\n\n\n\n
Tout le pattern repose sur trois briques :<\/p>\n\n\n\n