Partage
  • Partager sur Facebook
  • Partager sur Twitter

[ngl] Un langage de programmation générique

    22 juillet 2019 à 21:03:25

    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

    • Partager sur Facebook
    • Partager sur Twitter
      23 juillet 2019 à 16:07:12

      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

      • Partager sur Facebook
      • Partager sur Twitter
        23 juillet 2019 à 19:15:21

        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

        • Partager sur Facebook
        • Partager sur Twitter
          15 janvier 2020 à 19:37:45

          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

          • Partager sur Facebook
          • Partager sur Twitter
            25 avril 2020 à 15:48:43

            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.

            • Partager sur Facebook
            • Partager sur Twitter

            [ngl] Un langage de programmation générique

            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
            • Editeur
            • Markdown