Précédent
Suivant

L'interpréteur multilangage

1) Introduction

Il est facile de comprendre que le langage de programmation du future si ce n'est déjà le cas aujourd'hui, sera du pseudo code traité par l'IA. Et qu'est ce que le pseudo-code si ce n'est un code écrit dans un langage sur demande.... D'où l'importance de pouvoir choisir son langage de programmation. Ne dit-on pas que la moitier de la résolution d'un problème est résolue par sa formalisation dans un langage sur mesure ?

Les algèbres multi-sortes sont la base des interpréteurs multilangages. Néanmoins les expressions avec nom d'opérateur, parenthèse et virgule peuvent vite devenir illlisibles de par un trop grand nombre de parenthèses emboitées. Pour rendre le langage plus lisible pour un humain, on autorise des syntaxes alternatives, préfixe, infixe, postfixe et délimité, qui nous permettent de définir un véritable langage de programmation mutable. Et on envisagera l'utilisation de patrons, de macros, et d'autres nouveautés qui permettent de sous-entendre une partie de l'expression.

Les langages de programmation comme les langages scientifiques et mathématiques possèdent tous la propriété d'être facilement reconnaissable. Cela vient du fait que l'on souhaite condenser dans une formule un ensemble de connaissances à transmettre, et donc dont le but par principe est d'être facile à lire. Or qu'est ce que cela vaut dire "facilement reconnaissable" ? Que l'on repaire immédiatement l'éventuelle erreur de syntaxe. Partant de ce principe on s'intéresse qu'aux seuls langages dont la syntaxe est résolue par un automate, en une seule lecture de l'expression pour commencer. Cela va imposer un certain nombre de contraintes sur la conception du langage, et l'on ne pourra pas implémenter toutes les syntaxes altérnatives évoquées précédement en même temps ou sans autre contrainte.

La programmation assistée par l'IA, nous permet de mettre facilement en oeuvre les constructions d'algèbre multi-sorte ainsi que toutes sortes d'algorithmes applicables à ces structures. Cela modifit l'ordre des pertinences dans les constructions (et même des conceptions mathématiques). On s'attardera dans le choix d'une nomenclature de structures et d'une formalisation des opérations sur ces structures. Cela révèlera un nouvel attrait pour le constructivisme par le bas.

On discute avec l'IA sur les langages d'opérateurs et les automates reconnaissant ces langages. Puis on étend progressivement en plusieurs langages imbriqués avec leur automates les reconnaissant. Puis on étend les langages pour pouvoir programmer les automates eux-mêmes, et pour finalement proposer un interpréteur multilangage modifiable à volonté.

Le procédé pouvant prétendre à une certaine universalité, il sera rechercher une terminologie consensuelle (basée sur une norme hispano-latine telle que proposée par la communauté "Désanglisation de la programmation"), des mots-clefs qui donnent envie d'être utilisés.

Comme nous somme soucieux de rendre moins ingrate ces recherches pour ne pas décourager les néophytes, nous proposerons à chaque étape des résultats intermédiaires sous forme d'outils concrets programmé en python.

La première étape consiste en la conception d'un interpréteur d'algèbre multi-sorte, capable de reconnaitre un terme, capable d'énumérer tous les termes possibles, capable de générer un terme au hasard.

2) L'algèbre libre

La construction ayant quelque prétention à l'universalité, l'ordre des constructions et des concepts à définir revête une grande importance. Le premier prompt est celui définissant une algèbre libre engendrée par des opérateurs internes.

On définit un langage algébrique, et plus précisément un langage associé à une algèbre libre, en présentant ses éléments générateurs et ses opérateurs générateurs entre crochet <...>. Chaque opérateur possède une arité indiquée occasionnellement par le suffixe (.) pour unaire, (.,.) pour binaire, (.,.,.) pour ternaire. Exemple :

       `L = "<"a, b, f("."), g(".,."), h(".,.,.,.")">"`

Il convient de proposer à l'utilisateur les outils les plus démonstratifs avec les arguments par défaut necéssaires pour cela. Puis il est préférable de regouper ces informations concernant une structure dans la structure elle-même. C'est pourquoi on perfectionne tout de suite la définition du langage avec la possibilité d'ajouter des information concernant chaque symbole, et on commence par des poids associés à chaque générateur. Cela est nécessaire lorsque l'on veut générer au hasard un terme, ou attribuer aux termes une taille pondérée.

On ajoute un poids à chaque générateur. Le suffixe :p fixe le poids, positif, nul autorisé, 1 par défaut. Exemple :

       `L = "<"a":"9, b, f(".")":"3, g(".,."), h(".,.,.,.")">"`

Notre vision étant par essence récursive, on oriente notre IA dans cette vision d'un traitrement récurcif pour reconnaitre un terme du langage.

On définit un automate récursif qui reconnaît les termes du langage `"<"a, b, f("."), g(".,."), h(".,.,.,.")">"`. L'automate est représenté par un ensemble de règles de production :

`{"⊢"a, "⊢"b, "⊢"f("."), "⊢"g(".,."), "⊢"h(".,.,.,.")}`

Chaque élément de cet ensemble est une règle de production possible. Le symbole point désigne un terme quelconque du langage, et constitue un appel récursif de cet automate.

Sans développer davantage la conception du langage, on peut demander à l'IA de programmer une fonction idioma("<a,b,f(.), g(.,.),h(.,.,.)>") qui retourne l'automate capable de reconnaitre un élément du langage. Un petit synopsis à destination de l'utilisateur devra être consultable par une commande.

Programme en python une fonction idioma("`"<"a, b, f("."), g(".,."), h(".,.,.,.")">"`") qui retourne cet automate capable de reconnaître un terme du langage.

Et fait une synopsis à destination de l'utilisateur qui devra être accessible par la commande synop(idioma).

L'argument de idioma est une chaine de caractères écrites dans un méta-langage.

3) Terminologie hispano-latine

L'algèbre comprend un ensemble de règles de production, un ensemble d'éléments générateurs, un ensemble d'opérateurs générateurs, une liste de symboles générateurs (regroupant opérateurs générateur et éléments générateurs mais énuméré dans un ordre), et une méthode pour reconnaitre un terme.

A = idioma("`"<"a":"9, b, f(".")":"3, g(".,.")">"`")   
Construit l'automate `A`
Attributs :    
A.regles  =  `{'"⊢"g(".,.")', '"⊢"b', '"⊢"a', '"⊢"f(".")'}`
Régles de production
A.generateurs  =  `{'a'":"9, 'b'":"1}`
Eléments générateurs
A.operateurs  =  `{'f'":"(1,3), 'g'":"(2,1)}`
Opérateurs générateurs
A.symboles  =  `"["('a', 0, 9), ('b', 0, 1), ('f', 1, 3), ('g', 2, 1)"]"`    
Symboles générateurs
Méthodes :    
A.reconnait("`g(f(a),b)`")  =  vero
Teste si le terme appartient au langage.
A.reconnait("`g(f(b))`")  =  falso

Remarquez que l'argument de la méthode reconnait est une chaine de caractères pouvant représenter un terme du langage. En effet, un interpréteur analyse par principe une chaine de caractère. Les autres syntaxes concernant les attributs sont celles de python.

On peut penser que ces 4 attributs et cette méthode sont des identifiants suffisament généraux pour devoir leur attribuer des noms commun de programmation (mot-clef).

Voyons ce que ChatGPT peut nous proposer concernant le nom de méthode "reconnait" :

On définie un langage algébrique, et plus précisément un langage associé à une algèbre libre, par la liste de ses éléments générateurs et opérateurs générateurs entre crochets `"<"a, b, f("."), g(".,.")">"`. La fonction idioma appliqué à la chaine "`"<"a, b, f("."), g(".,.")">"`" retourne l'automate capable de reconnaitre un terme du langage algébrique en question.

Le nom idioma obéit bien à la norme hispano-latine.
L'automate possède une méthode, reconnait, qui appliqué à une chaine retourne vrai si c'est un terme du langage et faux sinon. Quel mot-clef de norme hispano-latine pourrait remplacer le nom de méthode reconnait ?
Dans ce cas précis, je choisirais acepta.

La distinction conceptuelle est utile :

  • un automate reconnaît un langage ;
  • un automate accepte ou rejette une chaîne particulière.

Ainsi :

</> Python

L = idioma("<a,b,f(.),g(.,.)>")

L.acepta("a")           # vero
L.acepta("f(a)")       # vero
L.acepta("g(a,b)")   # vero
L.acepta("g(a)")      # falso

acepta présente plusieurs avantages : c'est espagnol, très court, issu du latin acceptare, et son sens correspond exactement à l'usage classique en théorie des automates.

reconoce serait néanmoins également très bon, et c'est la traduction hispanique directe de reconnait :
L.reconoce("f(a)")

Mais je réserverais idéalement reconoce à une relation plus générale avec le langage :
« El autómata reconoce el idioma L. »
« El autómata acepta el término t. »

Une troisième possibilité serait pertenece, qui exprime directement l'appartenance :
L.pertenece("f(a)")

Cela se lit comme :
f(a) pertenece a L.

Mais grammaticalement, c'est plutôt le terme qui appartient au langage, et non le langage qui « pertenece » au terme. En notation objet, L.pertenece(t) est donc légèrement moins naturel.

Je proposerais donc la norme suivante :

Opération Mot-clef recommandé
Construire le langage / automate idioma(...)
Tester si une chaîne est un terme accepté acepta(...)
Dire qu'un automate reconnaît un langage reconoce(...)
Valeurs retournées vero / falso
Donc, pour votre bibliothèque, idioma(...).acepta(terme) me paraît être la formulation la plus précise et la plus élégante.

4) L'implémentation

Une fois posé le langage, il existe un cheminement de conceptualisations quasi-canonique définissant l'implémentation, l'implémentation par défaut, puis toute une liste de méta-opérations.

On part d'un langage L que l'on définit par l'instruction L = idioma("`"<"a, b, f("."), g(".,.")">"`"). C'est le langage d'une algèbre libre. Ce langage doit piloter un système. Cela se fait en associant à chaque élément une valeur dans le système piloté, et en associant à chaqe opérateur une procédure de même arité qui prend en argument des valeurs produites par le système piloté pour retourner une valeur produite par le système piloté. Cet ensemble de valeurs et de procédures associées constitue ce qu'on appelle l'implémentation du langage dans le système piloté. Notez que le système piloté peut alors être considéré comme définit par cette implémentation.

On procède à l'implémentation en associant à chaque élément générateur, une valeur. Et en associant à chaque opérateur générateur du langage, une procédure de même arité.

Pour le raisonnement, improvisons quelques notations que nous redéfinirons plutard. L'instruction Les instructions implemanta("a")=A et implemanta("f")=F vont modifier l'implémentation du langage comme suit : le symbole `a` sera associé à la valeur A, le symbole `f` sera associé à la procédure unaire F. Considérons par exelmple l'implémentation suivante :

L.implemanta("a") = A
L.implemanta("b") = B
Limplemantai("f") = F
L.implemanta("g") = G

L'évaluation d'un terme par exemple `g(f(a),b)` s'obtient en utilisant la méthode ejec du langage. La commande L.ejec("`g(f(a),b)`") exécutera G(F(A),B) et retournera son résultat. Cette méthode ejec constitue l'interpréteur. C'est l'opération de base d'un interpréteur appelée « traduction mot-à-mot  » appliqué ici à une simple algèbre libre.

Comme nous programmons cet interpréteur en python, les valeurs peuvent être de n'importe quel type python.

5) L'implémentation par défaut

Il existe une implémentation par défaut, où les valeurs produites, lorsqu'elles sont utilisées comme élément, sont converties en chaines de caractères désignant des termes d'un langage étendu. L'implémentation par défaut correspond à une extension du langage de départ. Elle dépend d'un convertisseur par défaut, str, transformant les valeurs en chaines de caractères.

L'implémentation par défaut tient en deux principes :

  1. Si une fonction appliquée à des arguments ne sait pas procéder à son calcul, elle produit alors, la chaine de caractères correspondant à l'appel de la fonction en remplaçant ses arguments par leur évaluation converti en chaine de caractères.
     
  2. Si une chaine de caractères ainsi créé ne constitue pas un appel de fonction connue, elle désigne alors un nouvelle élément que l'on ajoute au langage, associé à sa valeur native si elle existe.

5.1) Absence d'implémentation

Prenons par exemple l'implémentation suivante qui traduit en faite une absence d'implémentation :

L.implemanta("a") = None
L.implemanta("b") = None
L.implemanta("f") = None
L.implemanta("g") = None

L'évalution de "a" se fait en lançant l'instruction L.ejec("a"). Celle-ci tentera de retourner la valeur associée L.i("a"). Comme celle-ci n'est pas définie, elle retournera l'élément à évaluer tel quel, "a".

L'évalution de "f(a)" se fait en lançant l'instruction L.ejec("f(a)"). Elle commencera par évaluer l'argument "a" et le remplacera par le résultat, ce qui ne change rien ici. Puis, elle tentera d'exécuter la procédure associée à f avec l'argument évalué "a". Comme la procédure n'est pas définie, elle retournera l'opérateur f avec ces arguments évalués, c'est à dire "f(a)".

L'évalution de "g(a,f(b))" se fait en lançant l'instruction L.ejec("g(b,f(a))"). Elle commencera par évaluer les arguments "b" et "f(a)", ce qui ne change rien ici. Puis elle tentera d'exécuter la procédure associée à g avec les arguments évalués "b" et "f(a)". Comme celle-ci n'est pas définie, elle retournera l'opérateur g avec ces arguments évalués, c'est à dire "g(a,f(b))".

Finalement, l'absence d'implémentation correspondra à l'implémentation suivante :

L.implemanta("a") = "a"
L.implemanta("b") = "b"
L.implemanta("f") = {x| x=L.ejec(x); if ! isinstance(x, str) : x = str(x);
                  return "f("+X+")"
L.implemanta("g") = {x,y| x=L.ejec(x); if ! isinstance(x, str) : x = str(x);
                      y=L.ejec(y); if ! isinstance(y, str) : y = str(y);
                      return "f("+X+","+Y+")"

5.2) Implémentation d'un élément

Prenons par exemple l'implémentation suivante :

L.implemanta("a") = 27

L'évalution de "a" se fait en lançant l'instruction L.ejec("a"). Celle-ci retourner la valeur associée L.implemanta("a") c'est à dire 27.

L'évalution de "f(a)" se fait en lançant l'instruction L.ejec("f(a)"). Elle commencera par évaluer l'argument "a" par 27. Puis elle tentera d'exécuter la procédure associée à f. Comme cette procédure n'est pas définie, elle retournera l'opérateur f avec son argument évalué, 27, que l'on doit convertir en chaine de caractères "27", c'est à dire qu'elle retournra "f(27)".

Et cela a pour conséquence d'ajouter l'élément "27" associé à la valeur 27, au langage.

L.implemanta("27") = 27

Il y a une infime différence entre l'élément "a" et l'élément "27". L'évaluation de "a" retournera la valeur associé à l'élément "a", tandis que l'évaluation de "27" retournera la valeur associé à l'élément "27". C'est identique sauf que l'on verra plustard qu'il est possible de modifier l'implémentation en cours de route, et que l'on peut modifier indépendament la valeur de l'élément "a" et modifier indépendament la valeur de l'élément "27".

5.3) Implémentation d'un opérateur

Prenons par exemple l'implémentation suivante :

L.implemanta("a") = 27
L.implemanta("g") = {x,y | x+y}

L'évalution de "g(a,a)" se fait en lançant l'instruction L.ejec("g(a,a)"). Elle commencera par évaluer "a" en 27 une première fois pour le premier argument, et une seconde fois pour le second argument, sans les transformer en chaine de caractères, puis exécutera G(27,27) où G est la procédure mémorisée dans L.implemanta("g"), pour produire la valeur 54.

L'évaluation de "g(27,27)" va exécuter la procédure G sur des éléments qui ont été rajouté préalablement et associé à la valeur 27. Si tel n'était pas le cas, l'élément "27" serait inconnu et donc non-défini et donc de valeur par défaut lui-même c'est à dire "27". Dans le premier cas, cela exécutera G(27,27) pour produire la valeur 54. Dans le second cas cela exécutera G("27","27") et retournera "2727". Mais si la fonction G est définie plus précisément avec un domaine de définition plus restreint, et génère une erreur, alors le calcul ne pouvant se faire, celui-ci retourne la chaine de caractères correspondant à l'appel de la fonction en remplaçant ses arguments par leur évaluation converti en chaine de caractères, c'est à dire "g(27,27)".

L'évaluation de "g(27,a)" va exécuter la procédure G sur deux éléments s'évaluant en la valeur "27", c'est à dire G(27,27) ce qui produit la valeur 54. Remarquez que, tant que la valeur 54 n'est pas utilisée comme un élément du langage, il n'est pas converti en l'élément "54" associé à la valeur 54. Ceci afin de ne pas agrandire inutilement la liste des éléments générateurs du langage.

L'évaluation de "g(g(a,a),b)" commence par évaluer "a" en 27, et par évaluer "g(a,a)" en la valeur produite par G(27,27) c'est à dire 54, puis évalue "b" en "b", et exécute G(27,"b") ce qui est hors domaine, donc cela produit la chaine de caractères correspondant à l'appel de la fonction en remplaçant ses arguments par leur évaluation converti en chaine de caractères, "g(54,b)", où l'élément "54" associé à la valeur 54, est ajouté au langage s'il n'était pas déjà présent.

6) Les nouveaux langages

Les langages évolués sont encore des langages algébriques, et donc obéïssent aux règles précédentes. Et, il est tout à fait pertinent, utile, et politiquement crucial, à un moment où il est justement important de prendre position, de vouloir établir une norme sur les principes généraux de programmation, sur une base linguistique hispano-latine, sachant que les anciens langages ne seront peux ou plus utilisés dans la phase de conception des programmes.

Le "vibe coding" n'est qu'une phase brouillonne ou naîtra un langage plus évolué, franchissant une grande marche dans l'évolution. C'est pourquoi il existe un enjeux politique important, afin que la nouvelle norme ne soit pas décidé par des multinationales selon leur politique de domination commerciale ou autre, mais collectivement dans un autre cadre idéologique.

7) Terminologie hispano-latine (suite)

Voyons ce que ChatGPT peut nous proposer concernant le nom de méthode "implemanta" :

Étant donné un langage L=idioma("<a,b,f(.),g(.,.)>"). On définie une implémentation en associant à chaque élément générateur une valeur, et en associant à chaque opérateur une procédure de même arité. Comment appeler cette méthode F qui à chaque symbole va associer son implémentation. Par exemple :

L.F("a") = 27
L.F("b") = 5
L.F("f") = une procédure unaire
L.F("g") = une procédure binaire

Je choisirais interpreta.

Dans votre cadre algébrique, c’est même le terme mathématiquement le plus juste : une interprétation associe aux symboles d’une signature leur signification concrète — une valeur aux constantes et une fonction aux symboles opératoires.

Ainsi :

</> Python

L.interpreta("a") = 27
L.interpreta("b") = 5
L.interpreta("f") = fonction_unaire
L.interpreta("g") = fonction_binaire

On peut alors dire que interpreta définit l’interprétation des symboles générateurs.

Le terme convient très bien à votre norme hispano-latine :

  • espagnol : interpretar → interpreta
  • latin : interpretari
  • français : interpréter
  • italien : interpretare
  • portugais : interpretar

Il est donc beaucoup plus international-romain que implement, map, bind, etc.

Je distinguerais en revanche soigneusement trois notions :

Opération
Nom proposé
Rôle
L.acepta(x) 
acepta
détermine si x ∈ L
L.interpreta(s) 
interpreta
donne l'interprétation du symbole s
L.evalua(t) 
evalua
calcule la valeur d'un terme complet t

Par exemple, avec :

</> Python

L = idioma("<a,b,f(.),g(.,.)>")
L.interpreta("a") = 27
L.interpreta("b") = 5
L.interpreta("f") = lambda x: x + 1
L.interpreta("g") = lambda x, y: x * y

on aurait ensuite naturellement :

</> Python

L.evalua("a")
# 27

L.evalua("f(a)")
# 28

L.evalua("g(f(a),b)")
# 140

Cette séparation est conceptuellement forte :

interpreta agit sur les symboles ; evalua agit sur les termes.

Une autre possibilité : realiza

realiza serait également très intéressant si vous voulez insister non sur la sémantique, mais sur le fait qu'on donne une réalisation concrète au langage abstrait :

</> Python

L.realiza("a") = 27
L.realiza("f") = fonction

realizar vient également du latin realis. Mais, en algèbre et en logique, interpreta me paraît plus précis.

J'éviterais en revanche implementa. Même s'il est hispano-latin par sa forme, il décrit davantage la réalisation informatique d'une opération que l'association mathématique entre symbole formel et objet sémantique.

Je retiendrais donc pour votre vocabulaire :

idioma("<...>") construction du langage
acepta(x) appartenance au langage
interpreta(simbolo) symbole → valeur/fonction
evalua(termino) terme → valeur

Cela donne déjà un petit vocabulaire algébrique hispano-latin remarquablement régulier : idioma, acepta, interpreta, evalua, enumera..., genera....

 

---- 13 novembre 2026 ----

 

 

Répondre sur le Groupe Facebook

Répondre sur Communauté Reddit

 

 

Précédent
Suivant


Dominique Mabboux-Stromberg
(Septembre 2026)