Bonjour,

je travaille, depuis quelques temps, à la réalisation d'un langage de programmation en tant que projet personnel. Avant d'aller trop loin dans son implémentation, je souhaiterais recevoir quelques avis neufs et externes concernant sa "physiologie"; afin de voir là où cela semblerait plus défectueux, ou même proposer quelques ajouts / retranchements.

Je vais vous le présenter en quelques lignes, mais je vous donne également la documentation que j'avais précédemment écrite (tout n'y est plus d'actualité et il y a quelques petites fautes) si cela vous intéresse, ou si vous voulez vous faire une meilleure idée du langage

Paradigmes

Tout d'abord, je voulais concevoir ce langage (Arlia, de son petit nom) multi-paradigme mais avant tout orienté objet avec une définition relativement proche de l'originelle; évidemment, le langage étant également impératif, fonctionnel, méta programmable, ainsi qu'éventuellement événementielle, toutes les notions de tous ces paradigmes s'inter croisent, et ne sont donc pas tous respectés.

Concernant l'OO, je voulais surtout donner une vision "nouvelle" de celle que l'on a des langages tel que C#, Java, ou encore C++. J'ai d'ailleurs défini toute valeur manipulable comme étant un objet potentiel, dont on pouvait donner une définition, ou encore ajouter / modifier ces champs et méthodes. Ainsi, nous pouvons, par exemple, faire d'une simple chaine de caractère un objet "autonome" en modifiant ses propriétés standard :

Ou encore, permettre à un nombre (ou tout objet se comportant de la sorte) d'effectuer une procédure normalement intrinsèque au langage, tel qu'effectuer une boucle à la Ruby :

Ce n'est pas spécialement joli ni utile, mais c'est réalisable en Arlia, et de manière assez simple.

Types

Il faut également savoir qu'il n'existe pas du type standard en Arlia. Pas de int, double, float, char, ... Rien ! Le langage définit avant tout un type comme spécifiant la taille de l'objet en mémoire. Vous verrez, dans la documentation, qu'il y a plusieurs moyens de définir un type à une variable, je vous les montre simplement par code pour ne pas faire trop long :

Des types élémentaires sont quand même fournis depuis les bibliothèques du langage, comme on le voit à la dernière ligne .

Les tableaux et conteneurs

Je voulais également parler des tableaux et conteneurs. Typiquement, un conteneur est un tableau, mais j'entends ici un conteneur comme étant un "objet" (on peut comparer au C++ : std::vector, std::array, std::stack, ...)

En C-like, un tableau se déclare comme ceci :

int MyArray[size] = { values };

La taille est obligatoire (sauf si la valeur est déjà attribuée) et statique (pareille avec malloc, cette "fonction" doit avoir une taille bien précise à allouer en mémoire).

Dans mon langage, un tableau est automatiquement à taille dynamique (sauf si la taille est précisée) :

Et pour ajouter une valeur à un tableau à taille dynamique, nous utilisons simplement l'opérateur +=.

L'orienté objet

En Arlia, il n'y a pas nécessairement besoin du concept de "classe" pour créer des objets, d'ailleurs il n'existe pas. Nous avons juste besoin de savoir créer une instance d'objet. Pour ce faire, il existe plusieurs méthodes.

La première consiste à créer une structure que nous définirons postérieurement comme instanciable :

Ca, c'est la façon de faire "classique", et assez ressemblante au typedef du C-like (seulement au niveau visuel, car conceptuellement parlant, le mot clef data permet de définir une instance d'objet).

Nous pouvons également utiliser la macro object, qui ressemble s'y méprendre, aux classes :

La macro object est simplement une structure directement instanciée.

Et, pour finir, nous pouvons instancier une règle qui pourra englober plusieurs type de valeur :

Par exemple, ici, nous crée un objet dont la ne règle instaure que cet objet n'accepte que des valeurs paires. Le mot-clef is permet juste de vérifier le type d'une valeur/objet/variable.

Ce qui accroît considérablement les possibilités du langage selon moi, et le rend également plus clair et lisible. En C++ on aurait fait ça par exemple :

bool IsEven(int n) {
    return (n % 2 == 0);
}

if (IsEven(54)) {
    // Ok
}

if (IsEvent(13)) {
    // Nope
}

Un objet peut également changer sa propre implémentation, mais ce serait trop long à expliquer. Référez-vous à la doc si vous voulez

L'opérateur "avec"

Le langage offre la possibilité au développeur de définir une valeur précise sans passer par des boucles, ou des structures conditionnelles grâce à l'opérateur "avec" :|.

Pour ce faire, nous pouvons utiliser plusieurs éléments, tels que celui vu juste au-dessus (pour les nombres pairs), ou encore avec les conditions ternaires. Exemple :

Ceci est équivalent à ça :

Nous pouvons également définir la suite de Fibonacci en une seule ligne :

____

Voilà ! Il y a encore plein d'autres concepts, mais c'est principalement ceux-ci dont je voulais être sûr de la viabilité. Mais vous pouvez toujours réagir à la documentation.

Je vous remercie d'avance pour votre attention, et j'espère ne pas avoir été trop "barbant"

-
Edité par vanaur 2 août 2018 à 0:35:37

Lu'!

vanaur a écrit:

Concernant l'OO, je voulais surtout donner une vision "nouvelle" de celle que l'on a des langages tel que C#, Java, ou encore C++. J'ai d'ailleurs défini toute valeur manipulable comme étant un objet potentiel, dont on pouvait donner une définition, ou encore ajouter / modifier ces champs et méthodes.

https://en.wikipedia.org/wiki/Self_(programming_language)

vanaur a écrit:

• (1) Le mot clef data permet de définir une instance d'objet
• (2) Nous pouvons également utiliser la macro object, qui ressemble s'y méprendre, aux classes.

Ouais alors là par contre c'est casse gueule.

(1) Parler de "data" pour un objet alors que un objet est précisément pas des données, mais un comportement, ça va clairement rendre les choses incompréhensibles. Les objets définissent des traitements, pas des données. Les données sont une propriété interne, on ne sait même pas s'il y en a.

(2) Et là pareil, classe et objet c'est pas la même chose. Tu dis que :

vanaur a écrit:

La macro object est simplement une structure directement instanciée.

Sauf que visiblement non, pas du tout, puisqu'il faut que tu écrives :

var time : Time ;

pour obtenir effectivement une instance.

Après à propos du comparatif sur "even number" :

vanaur a écrit:

Par exemple, ici, nous crée un objet dont la ne règle instaure que cet objet n'accepte que des valeurs paires. Le mot-clef is permet juste de vérifier le type d'une valeur/objet/variable. Ce qui accroît considérablement les possibilités du langage selon moi, et le rend également plus clair et lisible.

C'est très discutable : les deux codes expriment exactement la même chose avec la même verbosité. A vrai dire, dans la version C++ avec un sucre syntaxique qui dirait que le premier paramètre d'une fonction peut toujours être utilisé en écrivant "paramètre.fonction" (et il y a des proposals dans ce sens), je pense que la version C++ est même plus claire.

vanaur a écrit:

Le langage offre la possibilité au développeur de définir une valeur précise sans passer par des boucles, ou des structures conditionnelles grâce à l'opérateur "avec" :|.

Je l'aurai plutôt appelé "tel que", car c'est plutôt à ça qu'il correspond en mathématiques.

Salut Ksass`, et merci pour ta réponse

Ça fait du bien un avis externe ! Je vois effectivement que ça coince à quelques endroits.

Ksass`Peuk a écrit:

vanaur a écrit:

• (1) Le mot clef data permet de définir une instance d'objet
• (2) Nous pouvons également utiliser la macro object, qui ressemble s'y méprendre, aux classes.

Ouais alors là par contre c'est casse gueule.

(1) Parler de "data" pour un objet alors que un objet est précisément pas des données, mais un comportement, ça va clairement rendre les choses incompréhensibles. Les objets définissent des traitements, pas des données. Les données sont une propriété interne, on ne sait même pas s'il y en a.

(2) Et là pareil, classe et objet c'est pas la même chose.

(1) Effectivement, je ne m'étais pas rendu compte de la confusion que cela pouvait apporter. Je devrais trouver un autre mot-clef que data dans ce cas... Que dirais-tu de quelque chose comme ça :

instance

Adapté au code précédemment donné :

instance Point : Coordinate;

Sauf que cela ne décrit pas très bien le comportement de manière "verbale"... A voir. (ou encore model ou même type comme en F#)

(2) Oui, en effet, maintenant que tu le dis.

Concernant la macro object en elle-même, c'est juste une structure qui donne directement une instance de l'objet :

data structure {
    ...
}

(Avec les nouveaux mots-clefs) :

instance structure {
    ...
}

model structure {
    ...
}

type structure {
    ...
}

(Personnellement, je trouve le premier plus explicite)

Ksass`Peuk a écrit:

C'est très discutable : les deux codes expriment exactement la même chose avec la même verbosité. A vrai dire, dans la version C++ avec un sucre syntaxique qui dirait que le premier paramètre d'une fonction peut toujours être utilisé en écrivant "paramètre.fonction" (et il y a des proposals dans ce sens), je pense que la version C++ est même plus claire.

Disons que c'est une version / vision différente dans ce cas Remarque : le langage permet également de faire ce qui fût fait avec le code C++.

Mais notons également que rule définit une règle en tant qu'objet. Je donne un autre exemple, pour qu'on se rend mieux compte du principe :

Une règle est donc globale au langage, et étant plus qu'un simple type puisqu'elle permet de "repérer" le comportement d'un objet, comme la chaine de caractère qui correspond donc à cette règle dans l'exemple.

Le ^ est simplement un opérateur de concaténation de tableaux.

it représente la valeur dans l'instance de l'objet (par exemple : var foo : integer = 8; ici it représentera 8).

Ksass`Peuk a écrit:

vanaur a écrit:

Le langage offre la possibilité au développeur de définir une valeur précise sans passer par des boucles, ou des structures conditionnelles grâce à l'opérateur "avec" :|.

Je l'aurai plutôt appelé "tel que", car c'est plutôt à ça qu'il correspond en mathématiques.

En effet, c'est plus logique.. Je changerai donc son nom.

PS: Désolé pour les quelques fautes syntaxiques et grammaticales de mon ancien message, il était 1H00, je devais être fatigué .

Merci encore Je suis ouvert à toutes autres propositions.

-
Edité par vanaur 2 août 2018 à 10:38:55

vanaur a écrit:

Concernant la macro object en elle-même, c'est juste une structure qui donne directement une instance de l'objet

Toujours pas convaincu. Dans ton exemple avec time, le mot "Time" que tu as déclaré à l'aide du mot clé "object" est utilisé à la position du type dans la déclaration de "time" :

var time : Time ;

"Time" n'est donc pas une instance, et c'est effectivement plus proche de la classe.

Que proposerais-tu dans ce cas ?

C'est compliqué de donner une réponse de but en blanc. Mais tu devrais te pencher sur ce que font les langages Self, SmallTalk ou encore JS.

J'y tâcherai

Merci.

vanaur a écrit: > Il faut également savoir qu'il n'existe pas du type standard en Arlia.

Pourtant je te vois manipuler nombres entiers, chaînes de caractères et autres tableaux, avec même des opérateurs dédiés spécifiquement à ces types.

entwanne a écrit:

Pourtant je te vois manipuler nombres entiers, chaînes de caractères et autres tableaux, avec même des opérateurs dédiés spécifiquement à ces types.

Alors, j'en mettrais pas ma main à couper mais de ce qu'il indique ces types font partie d'une bibliothèque standard.

Après, effectivement, c'est souvent à ce moment là que l'on atteint les limites de l'objet : on n'arrive à un moment où l'on n'a pas d'autre choix que montrer le détail d'implémentation, typiquement pour les entiers. Voir par exemple, le papier de Cook : On understanding data abstraction revisited.

Oui mais je vois mal comment les littéraux peuvent ne pas être partie intégrante du langage puisqu'il faut bien qu'ils soient reconnus par le parseur.

Question intéressante.

En fait, toutes données manipulables (nombres, caractères, chaines, tableaux, ...) est considérée comme étant un objet potentiel, auquel il est possible d'ajouter des attributs (des champs et des méthodes notamment). Mais, à l'état "élémentaire" de leurs utilisations, il faut bien qu'il y ait une base relativement stable sur laquelle s’appuyer pour les manipuler.

Ainsi, c'est nous qui décidons de "comment" les utiliser : en tant qu'objet, ou en tant que donnée littéral ?

Nous pouvons créer des règles, ou leur ajouter des attributs, mais nous ne pouvons pas changer leur nature de "nombre", "caractère", "chaine" ou "tableau". Par conséquent, pour répondre à ce besoin, le langage offre la possibilité de manipuler ce type de données élémentaires de manière classique, en offrant, comme tu l'as souligné, des opérateurs spécifiques selon les besoins.

Mais "tout" repose sur le concept de la potentialité de la donnée à se comporter comme un objet ou non.

Pour permettre une meilleure utilisation de ces littéraux, une bibliothèque pré-intégré (APIL) définit effectivement des types de données plus conventionnelles :

• integer ;
• char ;
• boolean ;
• string ;
• float ;
• array.

Ainsi, le chiffre 9 n'est pas défini dans une bibliothèque, il fait partie de la sémantique du langage en tant qu'objet potentiel, mais son utilisation peut varier selon la définition que nous lui attribuons. C'est à ce niveau-là que nous retrouvons le paradigme OO avec les "types standard" dans le langage.

J'espère que mon explication vous conviens à vous deux.

-
Edité par vanaur 5 août 2018 à 19:24:21