Syntaxe définition propres opérateurs + ordre de prioritée

Bonjour,

Comme vous l'avez peut être vu, je suis en train de développer un langage et je suis en train de chercher une syntaxe pour définir ses propres opérateurs.

Voilà la syntaxe pour surcharger un opérateur existant:

1
2
3
4
5
6
7
8

class A { # Définition classe
    Value_: int! = 0 # Création variable membre privée de type int

    pub implicit A(Value:int) { Value_ = Value } # Déclaration constructeur publique appelable implicitement
    pub operator +(Rhs: A) -> A! { # Déclaration opérateur qui prend qui additionne les valeurs
        Value_ + Rhs::Value_
    }
}

Mais maintenant, je cherche une syntaxe pour que l'utilisateur définisse un opérateur qui n'existe pas comme il veut. Mais du coup, il faut lui assigner un ordre de priorité et là, je trouve pas de syntaxe satisfaisante.
Pour définir un opérateur perso, j'ai pensé comme ça:

1
2
3
4
5
6

operator Plus(Lhs:A, Rhs:A) -> A! {
    Lhs + Rhs # Opérateur '+' défini avant
}
TestA:A = 10 # Constructeur déclaré "implicitement" donc pas besoin de faire = A 10
TestB:A = 10 # Idem
Print (TestA Plus TestB) # Affiche 20

Là, rien n'indique l'ordre de priorité. Auriez vous une manière élégante de l'indiquer ?

Merci,
Ardakaniz

Merci beaucoup !

Je pense que je vais partir sur la syntaxe de Berdes et faire quelque chose comme:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

operator<+> `Plus`(Lhs: A, Rhs: A) -> A! { // Même priorité que l'opérateur +
    Lhs + Rhs
}
operator<higest> ++(Lhs: void, Rhs: int!&) -> int! { // Prioritée la plus grande (par exemple 50000)
    Rhs = Rhs + 1 # On additionne Rhs à 1
    Rhs # Et on le renvoi
}
operator<smallest> ++(Lhs: int!&, Rhs: void) -> int! { // Prioritée la plus petite (0) {
    Lhs = Lhs + 1
    Lhs
}
operator<||, &&> &|(Lhs: bool, Rhs: bool) -> bool { // Priorité entre && et ||
    (Lhs || Rhs) && !(Lhs && Rhs) // Y'a moyen de faire plus court, mais je ne m'en rappelle plus.
}

Var: int = 4
PrintLine (Var `Plus` 5) // 9
PrintLine ++Var // 5 car plus grand priorité
PrintLine Var++ // 5 car plus petite priorité mais:
PrintLine Var // vaut maintenant 6
PrintLine (true &| false) // true
PrintLine (true &| true) // false
PrintLine (false &| false) // false

Après, j'ai rien d'implanter encore donc à voire, mais je pense que c'est pas mal

Sincèrement, mon idée de définir la priorité d'un opérateur en fonction comme étant entre deux autres opérateurs peut semble élégante et pratique. Mais en réalité, ça risque de causer bien plus de soucis que prévu en ajoutant (potentiellement non intentionnellement) beaucoup d’ambiguïté.

En fait, le problème est d'arriver à transformer un ordre partiel en ordre total. Et ce, de manière non ambiguë. Et ça, ça me semble pas simple (pour ne pas dire impossible).

Après, tu fais ce que tu veux. D'une certaine manière, ça permettrait aussi d'expérimenter et de voir si les problématiques théoriques que je te montrent se traduisent en réels problèmes à l'utilisation.

Edit : par contre, il pourrait être possible de définir de manière non ambiguë une priorité relative en indiquant qu'un opérateur à la priorité la plus petite strictement plus grande que + et inférieur à *. Dans un tel cas, mon premier exemple avec +., *. et ++ n'est plus ambiguë puisque l'on obtient l'ordre + < +. = *. < ++ < *, en supposant que les priorités sont les plus faibles possibles. Par contre, ça ne résout peut-être pas toutes les ambiguïtés.

Quid de l'associativité ?

1
2
3
4
5

operator<+> `Minus`(Lhs: A, Rhs: A) -> A! {
    Lhs - Rhs
}

PrintLine (4 `Minus` 3 `Minus` 1) // (4-3)-1 ou 4-(3-1) ? Comment définir l'associativité ?

Ah ouais.

Pffff, c'est beaucoup plus compliqué que ce que je pensais.... Je vais y réfléchir. Mais si vraiment, c'est trop compliqué, je pense que je vais pas l'implanter en fait. Mais ce serait dommage

EDIT:

1
2
3

operator<+,*> +.                
operator<+,*> *.                   
operator<+.,*> ++    

Imaginos que + est une priorité de 1 et * de 2. operator<+,> donne une priorité de (1 + 2) / 2 = 1.5. Donc les priorités de +. et de . sont les mêmes.
= + < +. = *. < ++ < *

En effet, c'est une autre solution

Pour l'associativité: 4 - 3 - 1 donne (4 - 3) - 1. Mais je vois pas d'exemples où ce serait le contraire ?

L'opérateur puissance par exemple est associatif à droite. En Python :

1
2
3
4

>>> 2**3**2
512
>>> (2**3)**2
64

On peut imaginer d'autres trucs, comme par exemple un opérateur a_mangé, qui s'utiliserait : oiseau a_mangé serpent a_mangé rongeur. Ici, c'est bien le serpent qui a mangé le rongeur, et pas l'oiseau qui a mangé le serpent et le rongeur (c'est un exemple bête, juste histoire d'illustrer).

Ok donc:

1
2
3

operator<+, left> `Minus`(Lhs: A, Rhs: A) -> A! {
    Lhs - Rhs
}

Bonjour, Comme vous l'avez peut être vu, je suis en train de développer un langage

Salut, où est le code du projet ?

J'avais un sujet, mais j'ai changé de nom et de syntaxe et ajoute des features. Bref plus du tout le meme. J'ai donc signale le sujet obsolète. Sinon le code est sur mon git, mais encore une fois c'est l'ancien. Et puis rien n'est en place pour l'instant, j'attends le tuto sur LLVM (oui, j'ai le temps…)

Ne te sens pas forcé d'attendre un tuto LLVM pour faire un compilateur qui l'utilise. Pour en avoir aussi écrit un sans connaitre LLVM avant, la documentation et les présentation sont vraiment bien faites. Au final, je n'ai pas eu besoin de plus que quelques exemples et de la doc pour faire un truc complet. Certes, probablement pas parfait, mais complet quand même.

Tu as une présentation qui contient un nombre incroyable de ressources différentes : LLVM Overview. Il suffit de regarder une ou deux intro pour pouvoir commencer à faire quelque chose d'intéressant. Et tu as la doc LLVM Language Reference Manual pour quand tu cherches une instruction particulière ou que tu veux une info précise sur un point.

Il y a aussi l'opérateur d'assignation qui est bien souvent associatif à droite : a = b = 0 équivaut bien à a = (b = 0).

@Berdes: Ouais, mais mon problème c'est que je galère à l'installer Tu aurais pas un tuto ?

Merci

Si l'anglais ne te fait pas peur, tu as un guide dans l'aide : Getting Started with LLVM.