En formalisant ce qu'est un interpréteur, ce qu'est un processus, les schémas de circulation et de référencement de l'information, la topologie des entrées/sorties, on construit un langage de base, que l'on perfectionne par étape, où à chaque étape on ajoute un nouveau concept.
Le premier concept est l'algèbre libre vue précédement, qui permet de piloter un système à l'aide d'un langage algébrique, le langage d'une algèbre libre. Par exemple considérons l'algèbre libre engendré par <a,b,f(.),g(.,.)>. On doit pouvoir ajouter des informations pour chaque opérateur. Les premières informations comprennent :
Nous avons définie deux méthodes : acepta et ejec
L= idioma("<a,b,f(.),g(.,.)>")
L.acepta("g(a,b,a)")
L.ejec("f(b)")Crée un langage L
Teste si "g(a,b,a)" appartient à L
Exécute le programme "f(b)" implémenté par L
Il existe 5 autres méthodes importantes :.
Voyons qu'est-ce que l'IA peut nous proposer comme mot-clef de norme hispano-latine pour ces 5 méthodes :
Pour rester cohérent avec idioma(...) et acepta(x), je vous conseille des noms verbaux, immédiatement lisibles en espagnol, sans accent, et construits de façon régulière.
Je proposerais ce noyau :
Énumérer tous les termes par taille croissante enumera_tamano() énumère selon la taille Énumérer les termes de taille exactement n enumera_tamano(n) énumère ceux de taille n Énumérer tous les termes par poids croissant enumera_peso() énumère selon le poids Énumérer les termes de poids exactement n enumera_peso(n) énumère ceux de poids n Générer un terme aléatoire genera_azar() génère au hasard Cette solution a un avantage important : les méthodes 1–4 se réduisent en réalité à deux méthodes paramétrables.
L = idioma("<a,b,f(.),g(.,.)>") # crée le langage L
L.acepta("f(a)") # vérifie si "f(a)" appartient à L
L.enumera_tamano() # tous les termes, par taille croissante
L.enumera_tamano(3) # seulement les termes de taille 3
L.enumera_peso() # tous les termes, par poids croissant
L.enumera_peso(7) # seulement les termes de poids 7
L.genera_azar() # un terme aléatoirePourquoi enumera ?
enumera me paraît particulièrement adapté à votre norme. Le mot espagnol enumerar vient du latin enumerare. Il est donc à la fois hispanique, latin et techniquement très précis.
Il exprime mieux le concept que des traductions de termes informatiques anglais comme list, iterate, walk ou generate.
Il faut aussi distinguer énumération et génération :
- enumera... parcourt systématiquement un ensemble de termes ;
- genera... produit un terme selon un procédé particulier.
Pourquoi tamano ?
En espagnol ce serait normalement tamaño. Puisqu'un mot-clef informatique gagne à rester facilement saisissable sur tous les claviers, je recommande : tamano plutôt que tamaño
Cela correspond à votre principe de romanisation sans signes diacritiques.
Pour le hasard : azar plutôt que aleatorio
On pourrait écrire : L.genera_aleatorio() mais grammaticalement ce serait plutôt genera aleatoriamente ou genera un término aleatorio. Je préfère :
L.genera_azar()
parce que azar est court et signifie directement « hasard ».
Une autre possibilité très élégante serait : L.genera_caso() au sens latin de casus, ce qui arrive fortuitement, mais caso a déjà un autre sens informatique important (case). Je l'écarterais donc.
Une variante encore plus régulière
On pourrait expliciter les prépositions :
L.enumera_por_tamano()
L.enumera_de_tamano(3)L.enumera_por_peso()
L.enumera_de_peso(7)C'est linguistiquement très clair :
- por_tamano = ordonné selon la taille ;
- de_tamano(n) = ayant la taille n.
Mais cela introduit quatre noms de méthodes alors que deux suffisent. Pour une API compacte, je préfère donc :acepta(x)
enumera_tamano()
enumera_tamano(n)enumera_peso()
enumera_peso(n)genera_azar()
Je trouve que cela commence à former un vocabulaire assez cohérent : idioma désigne le langage, acepta exprime l'appartenance, enumera parcourt systématiquement ses termes et genera en produit un.
Le second concept est l'algèbre multi-sorte qui permet d'enrichire la syntaxe en incorporant plusieurs langage algébrique, et donc plusieurs types, un type par langage algébrique. Comme il y a plusieurs types, on utilise le nom du type pour indiquer le type de l'argument, le point désignant toujours n'importe quel élément de la structure.
Par exemple considérons l'algèbre multisorte libre suivante : L = < a, b, f(H), g(.,L) >, H = < a, f(L) >. Elle comprend deux types propres L et H, et un type point qui correpsond toujours aux éléments de la structure c'est à dire à l'union de L et de H.
Pour des raisons évidentes de lisibilité, chaque sous-structure L et H a son propre espace de noms, faisant que l'élément a dans L et distinct de l'élément a dans H, et de même pour l'opérateur f. Le nom complet de l'élément est L.a ou H.a, et deux noms distincts d'élément dans une structure libre (une algèbre multisorte libre) désignent nécessairement deux éléments distincts.
L'algèbre multi-sorte libre est une partie de l'algèbre englobante libre < L.a, L.b, L.f(.), L.g(.,.), H.a, H.f(.) >
---- 19 octobre 2026 ----
idioma
adapté à l'utilisateur grace aux différentes syntaxe ; préfixe, postfixe, infixe et délimité.Une syntaxe alternative. (Par défaut c'est la syntaxe anglaise. Exemple g(x,y))
Le troisième concept est celle de variable, consite à définir les variables
....
....
Il existe de nombreuses possibilités pour enrichire le langage et en faire un langage de programmation évoluée. Mais l'une d'entre-elles prédomine largement quasi-toutes. Elle consiste à ne peut se rétreindre aux seuls valeurs d'évaluation, mais à considérer des flux de valeurs manipulables comme des simples variables.
Pour les distinguer des paramètres simple valeur, on notes les flux en majuscule. Et, ils ont deux modes possibles, synchrone ou asynchrone.
Répondre sur Communauté Reddit