Neuroshok Generic Language

Le but de ce projet est de créer un langage de programmation orienté généricité. Serveur discord du projet : Serveur discord du projet : https://discord.gg/8sB4rTF

Concept général

Le langage défini toute information en tant que data. Ces informations seront connectées entre elles de différentes façons afin de créer une logique.

Afin d'ajouter du sens à ces informations, elles doivent être décrites par une entité logique appelé descriptor. Une entité logique est une information concrète qui possède des concepts et une logique. La description d'une information se fait à partir d'un descripteur, qui devra donc se décrire lui même

Les data sont séparées en deux grandes parties, les concept ajoutant une logique à une information et les concrete représentant une concrétisation d'un concept dans l'environement du programme.

Voici un aperçu des spécificités prévues:

• Syntaxe
  • Le code devra être facile à lire et à écrire (pas d'excès de symboles)
  • La syntaxe sera uniforme (pas de spécificité selon la sémantique)

• Logique

  • Le langage utilisera des concepts pour la généricité des programmes
  • Une même entité logique (programme, IA ..) possèdera une seule version de ses concepts
  • Les concepts de différentes entités seront compatibles et substituables (dans le but d'éviter la redondance de concepts similaires au sein d'un programme utilisant plusieurs dépendances)
  • Chaque concept du langage sera parametrable

• Concrétisation

  • Le code source d'un programme étant un concept, il sera concrétisé en passant par plusieurs phases
  • La concrétisation d'un concept doit permettre de pouvoir modifier le concept en cours de concrétisation (metaprog)
  • La librairie du langage fournira les concepts nécessaires à la création de programme/projets (un système de build externe ne sera pas nécessaire)

Objectif

Dans un premier temps, le but sera de définir le langage, écrire la documentation et quelques concepts de la librairie standard tout en écrivant du code de test pour vérifier la cohérence du langage.

Une fois les bases du langage bien définies, l'écriture du compilateur sera envisageable. Il sera codé en C++ avec LLVM.

Recrutement

Je cherche donc des personnes intéressées par

• la définition du langage et de ses concepts
• l'écriture de code ngl de test
• l'implémentation expérimentale de fonctionnalités du compilateur

Et pour finir, voici un exemple simple de code

ngl:concept:container matrix
{
    ngl:concept:number <rows> // 1
    ngl:concept:number <columns> // 2
    ngl::concept:size ( rows * columns )
    
    <data_type> :data // 3, redescribe :data from ngl::container
}

// parameters order
matrix<4, 2, ngl::float> float_matrix;

-
Edité par ads00 15 janvier 2020 à 19:54:17

si c'Est ton propre langage je me demande la pertinence de tout préfixer de ngl:: ?

concept:container matrix
{
    concept:number <rows> // 1
    concept:number <columns>; // 2
    concept:size ( rows * columns )
    
    <data_type> : data // 3, redescribe :data from container
}

// parameters order
matrix<4, 2, float> float_matrix;

-
Edité par CrevetteMagique 23 juillet 2019 à 16:07:37

Car `ngl` est définit en tant que `self descriptor`qui définit ses propres concepts et qu'il est possible d'en utiliser d'autres.
Donc ngl: est un chemin connu, concept: n'en est pas un. Ce n'est pas un namespace.

Simplifier la syntaxe à ce stade apporterait plus de problèmes qu'autre chose, ce n'est pas une priorité. Sachant qu'on peut déjà utiliser des alias qui permettent d'avoir le même résultat explicitement

ngl:alias<ngl:concept> ngc;

ngc:container matrix
{
    ngc:number <rows>
    ngc:number <columns>
    ngc:size ( rows * columns )
    
    <data_type> :data
}

 Il y aura surement pas mal d'alias dans la librairie standard.

Il n'y a pas d'identifiant réservé , chaque nouvel identifiant est définit à partir d'un autre existant, ça permet d'éviter certains problèmes de nommage.

-
Edité par ads00 23 juillet 2019 à 19:17:15

Salut,

La doc avance doucement pour essayer de clarifier toutes les idées : https://github.com/ads00/ngl/blob/master/doc/index.md

J'ai ajouté plusieurs concepts :
- les "rule" qui permettent de créer des règles logiques pour les informations
- les "shape" qui permettent de définir une forme logique pour une donnée via l'utilisation des "rule"

Cela permet par exemple d'ajouter au langage le concept de constante

ngl constant
{
    <ngl:data>
    ngl:rule
    {
        ! ngl:edge // refuse all edges
        ngl:edge:read // allow read edge
    }
}

ngl:constant<4> my_int
my_int = 3 // ngl add the edge write from my_int to literal_3
           // ngl:edge<ngl, my_int, literal_3, write>
           // broken rule
an_int = my_int // ngl add the edge read from an_int to my_int
                // ngl:edge<ngl, an_int, my_int, read>
                // ok

On pourrait donc également créer une règle pour une division

ngl:rule no_zero
{
    ngc:number <value>
    ngl:rule (value != 0)
}
ngl:function divide
{
    ngc:int <x>
    ngc:int <y>
   
    ngl:rule:no_zero<y>

    .result (x / y)
}

Ce qui facilitera la généricité sur la gestion des erreurs.

Les "shape" permettront aussi de gérer tout ce qui est syntaxe, formats, langages de grammaire etc ..
Pour par exemple ajouter la gestion du xml dans un code source, avoir un système de log avec une syntaxe plus pratique etc ..

ngl:concept digit
{
    ngl:data <value>
    ngl:rule
    {
        value == ('0' | '1' .. | '9')
    }
}

Je passerai ensuite à la gestion des "edge" puis on recommencera à faire des tests

-
Edité par ads00 15 janvier 2020 à 19:39:32

Salut !

J'avais commencé des tests pour le compilateur avec antlr4 mais comme j'aimerais pouvoir ajouter des règles pour le lexer pendant la compilation, je vais plutôt partir sur un truc maison.

Le but du jeu est donc de définir la syntaxe du langage avec le langage en essayant de faire mieux qu'avec une lib (pegtl comme référence).

Pour ça on va juste utiliser le principe des rules, avec la forme la plus générique ça donne :

ngl:data bidule
{
    ngl:rule
    {
        expression_logique1
        expression_logique2
    }
}

Pour simplifier ça, on va utiliser les shapes, ce qui donnerait

ngl:shape:element comparison [==] // == doit exister 

ngl:shape comparison_expr // truc == bidule
{
    comparison_expr == [ngl:shape:identifier comparison ngl:shape:identifier]
}

Il faut bien sur des éléments primitifs pour ces descriptions, l'objectif est d'en avoir le moins possible et qu'ils puissent être redéfinis.

Salut,

Je ne met pas trop de news ici mais voici la nouvelle doc : https://ngl.neuroshok.com/doc/

Et un exemple de parsing assez expérimental

std::string data = "aa:bb zeta";

a | S000000000000001110000010 | Q000000000000000000000000 | M000000000000000000000000 | P000000000000001000000000
a | S000000000000001110000010 | Q000000000000000000000000 | M000000000000000000000000 | P000000000000001000000000
: | S000000000000010000100000 | Q000000000000000000000000 | M000000000000000000100000 | P000000000000010000000000
b | S000000000000011110000010 | Q000000000000000000000000 | M000000000000000000000000 | P000000000000011000000000
b | S000000000000011110000010 | Q000000000000000000000000 | M000000000000000000000000 | P000000000000011000000000
  | S000000000000000000000001 | Q000000000000000000000000 | M000000000000000000000001 | P000000000000000000000000
z | S000000000000001110000010 | Q000000000000000000000000 | M000000000000000000000000 | P000000000000001000000000
e | S000000000000001110000010 | Q000000000000000000000000 | M000000000000000000000000 | P000000000000001000000000
t | S000000000000001110000010 | Q000000000000000000000000 | M000000000000000000000000 | P000000000000001000000000
a | S000000000000001110000010 | Q000000000000000000000000 | M000000000000000000000000 | P000000000000001000000000