Discussion :

[Lolo78]

Bonjour,

j'ai le plaisir d'annoncer la mise en ligne ce matin d'un nouveau tutoriel:

Les regex et grammaires de Perl 6, une puissance expressive sans précédent.

La puissance des expressions régulières de Perl 5 a longtemps fait de ce langage l'instrument de choix par excellence pour analyser des données textuelles. Depuis, de nombreux autres langages de programmation ont cherché à copier les expressions régulières de Perl

Le nouveau langage Perl 6, dérivé de Perl 5, crée un nouveau modèle de reconnaissance textuelle dérivé des expressions régulières, mais considérablement plus puissant et plus expressif, et si éloigné des expressions régulières d'origine qu'il a été décidé de leur donner un nouveau nom, les regex.

Non seulement le mécanisme des regex de Perl 6 est-il considérablement plus puissant que tous les systèmes d'expressions régulières existants, mais il a été conçu de façon à pouvoir combiner des regex pour construire des grammaires contextuelles, c'est-à-dire des systèmes capables de réaliser l'analyse lexicale et syntaxique (lexing et parsing) de données beaucoup plus complexes, comme des textes HTML, XML, XHTML, JSON, YAML, qui, hors cas triviaux, sont hors de portée des expressions régulières traditionnelles. Ces grammaires peuvent notamment analyser des programmes informatiques de tous niveaux. Perl 6 lui-même est compilé avec sa propre grammaire écrite en Perl 6.

Même si elles sont loin d'être la seule innovation de Perl 6, les regex et les grammaires de Perl 6 sont à notre avis susceptibles de révolutionner les langages informatiques au moins aussi profondément, et peut-être beaucoup plus, que les expressions régulières de Perl 5 ne l'avaient fait en leur temps.

Les commentaires sont les bienvenus.

[djibril]

Bonjour Laurent,

Avec tous tes supers tutoriels sur Perl 6, cela donnera envie à énormément de programmeurs de s'y jeter afin de tester toutes les merveilles du langage Perl et Perl 6.

Merci pour ce boulot titanesque.



Djibril

[BufferBob]

si éloigné des expressions régulières d'origine qu'il a été décidé de leur donner un nouveau nom, les regex.

De L'Art de lever toute ambiguïté

sinon merci pour ce tutoriel, c'est vrai que ça a l'air extra ces nouvelles regex, on retrouve clairement un arrière gout de YAML, c'est finalement assez cohérent si on considère que Perl a toujours été voué à faire du parsing, il offre désormais de quoi écrire des parsers évolués, structurés et modernes, à voir si le temps lui rendra justice (dans des domaines comme le traitement automatisé du langage naturel par exemple)

Edit:

Merci pour ce boulot titanesque.

ah oui, je plussoie

[Lolo78]

Merci à vous deux.

Avec tous tes supers tutoriels sur Perl 6, cela donnera envie à énormément de programmeurs de s'y jeter afin de tester toutes les merveilles du langage Perl et Perl 6.

C'est bien ce que je souhaite, donner envie à plein de programmeurs d'essayer toutes ces merveilles.

Et franchement, les grammaires, ça demande un petit investissement initial, mais c'est vite vraiment amusant, un modèle de programmation qui ressemble un peu à la programmation logique (notamment au Prolog que j'ai un peu pratiqué pendant mes études, ça rappelle des souvenirs). J'ai envie d'essayer de faire un truc bien farfelu avec les grammaires, pour le fun, genre un petit moteur de programmation par contraintes ou de programmation déclarative pour parcourir un graphe, un machin complètement inutile (encore que...) mais bien amusant, mais j'ai pas encore trouvé quoi exactement.

[Roland Chastain]

Bonjour !

J'ai lu ce tutoriel avec un vif intérêt, quoique je n'en aie pas (encore) assimilé toute la substance, étant débutant en Perl et plus débutant encore en Perl 6. Bravo pour ce travail !

un machin complètement inutile (encore que...) mais bien amusant, mais j'ai pas encore trouvé quoi exactement.

L'idée qui me trotte dans la tête depuis que j'ai vu l'article, ce serait de faire un script qui (pour commencer) serait capable d'extraire d'un code source ses différents mots-clés (constantes, variables, fonctions...). Par exemple (c'est ce qui m'intéresserait) d'un code source en Pascal. Si tu pouvais faire un exemple qui montre le principe d'une opération de ce genre, je serais preneur.

Mais j'ai vu qu'il y avait déjà dans le tutoriel un exemple d'extraction de données au format JSON. Il faut que je le relise...

[Lolo78]

Bonjour Roland,
merci pour ton commentaire.

L'idée qui me trotte dans la tête depuis que j'ai vu l'article, ce serait de faire un script qui (pour commencer) serait capable d'extraire d'un code source ses différents mots-clés (constantes, variables, fonctions...). Par exemple (c'est ce qui m'intéresserait) d'un code source en Pascal. Si tu pouvais faire un exemple qui montre le principe d'une opération de ce genre, je serais preneur.

Pourquoi pas? On pourrait éventuellement commencer avec un sous-ensemble de Pascal, parce que se palucher toute la grammaire de Pascal, ça risque d'être beaucoup (et puis ça fait des années que je n'ai plus fait de Pascal, il faudrait que je m'y remette un peu, mais je suis tout-à-fait ouvert sur la question). Et si on arrive à faire quelque chose d'intéressant, je pourrais peut-être ajouter l'exemple à mon article.

Il faudrait que tu précises ce que tu désires faire au juste avec ça et qu'on en discute un peu. Mais ce thème étant quelque peu hors-sujet ici, je propose qu'on en discute ailleurs. Peut-être peux-tu m'envoyer des informations par MP, ainsi qu'une adresse mail (voire un ID Skype) pour faciliter les échanges.

[Roland Chastain]

Pourquoi pas? On pourrait éventuellement commencer avec un sous-ensemble de Pascal, parce que se palucher toute la grammaire de Pascal, ça risque d'être beaucoup (et puis ça fait des années que je n'ai plus fait de Pascal, il faudrait que je m'y remette un peu, mais je suis tout-à-fait ouvert sur la question). Et si on arrive à faire quelque chose d'intéressant, je pourrais peut-être ajouter l'exemple à mon article.

Il faudrait que tu précises ce que tu désires faire au juste avec ça et qu'on en discute un peu. Mais ce thème étant quelque peu hors-sujet ici, je propose qu'on en discute ailleurs. Peut-être peux-tu m'envoyer des informations par MP, ainsi qu'une adresse mail (voire un ID Skype) pour faciliter les échanges.

Merci pour cette aimable réponse. Je te contacte par MP dans les jours qui viennent.

[Philou67430]

Je n'ai pas encore lu l'article, mais le pitch fait envie (de le lire et de pratiquer les regex)... si je remets la main sur mon programme lisp de calcul formel du temps ou j'étais étudiant (que j'avais déjà réécrit en prolog), c'est bien le genre de "truc inutile (quoique)" que je serais tenté de porter à nouveau ...

Edit : je n'ai pas lu l'article, mais j'ai déjà cpané le module Perl6::Rules

[Lolo78]

Bonjour,

j'ai procédé la semaine dernière à une mise à jour importante de l'article sur les Regex et les Grammaires de Perl 6, avec en particulier l'ajout de quelques pages relatives aux utilisations avancées des grammaires, notamment:

• les règles paramétrées,
• les règles récursives et les variables dynamiques,

qui ajoutent à la puissance et à l'expressivité de ces grammaires, et une multitude d'améliorations de détail.

Si vous avez téléchargé la version antérieure, n'hésitez pas à revenir pour prendre connaissance de cette nouvelle version.

Bonne lecture à tous,

Laurent.

[jeepc]

Bonjour,

Merci pour tous ces tutoriels perl6 qui sont vraiment très utiles.

Du coup, j'essaie d'utiliser une grammaire en Perl6. J'ai une question qui porte certainement plus sur l'écriture de la grammaire que sur Perl6. Si ce n'est pas le bon endroit pour poser cette question ,peut-être pourriez-vous m'indiquer où puis je poser cette question ?

Voici l'exemple qui illustre ma question :

Le code suivant analyse une commande de la forme @script [para1] [para2] [par2] [para4]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
######################
use v6;
 
grammar TEST {
 
    rule TOP {  [ <run> <params> ]
                | [ <run> ] }
    rule run { <at><cmdfile> }
    token cmdfile { <[ a..z A..Z 0..9 \-_.!~*'():@&=+$,/\' ]>+ }
    rule params {
                 <param> <param> <param> <param>
               | <param> <param> <param>
               | <param> <param>
               | <param> }
 
    token param { <[ a..z A..Z 0..9 \-_.!~*'():@&=+$,/\' ]>+ }
    token at   {  '@' }
}
 
my $ctl = "@run para1 par2";
say $ctl;
my $m = TEST.parse( $ctl);
say $m;
###########################
 
 
Ce code fonctionne:
 
@run para1 par2
｢@run para1 par2｣
 run => ｢@run ｣
  at => ｢@｣
  cmdfile => ｢run｣
 params => ｢para1 par2｣
  param => ｢para1｣
  param => ｢par2｣

Par contre, je n'arrive pas à trouver la syntaxe qui me permettrait de ne pas avoir un nombre fini de paramètres. ( 4 dans mon exemple )
Savez-vous comment exprimer cela ?

Merci beaucoup pour votre aide.
Bien cordialement,

[Philou67430]

Peut-être en écrivant ce qui suit ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

rule params { <param> * }

[Lolo78]

Peut-être en écrivant ce qui suit ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
rule params { <param> * }

Oui, exactement, c'est la façon la plus simple. Ou peut-être plutôt:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
rule params { <param> + }

pour garantir qu'il y ait au moins une fois le token param.

[Philou67430]

J'imagine également que l'on peut imposer un quantifier du style { min, max }

[Lolo78]

Oui, on peut, sauf qu'en Perl 6, ce quantificateur s'écrit: "** $min..$max".

[Philou67430]

Devant mon ignorance crasse en P6, je n'ai pas osé proposer une syntaxe

[jeepc]

Super. Merci beaucoup pour vos réponses rapides.

Du coup, je peux même simplifier la grammaire qui devient (comme je suis dans le cas de figure où il peut ne pas y avoir de paramètre) :

grammar TEST is export {

rule TOP { [ <run> <params> ] }
rule run { <at><cmdfile> }
token cmdfile { <[ a..z A..Z 0..9 \-_.!~*'():@&=+$,/\' ]>+ }
rule params { <param> * }
token param { <[ a..z A..Z 0..9 \-_.!~*'():@&=+$,/\' ]>+ }
token at { '@' }
}


Encore merci.
Bien cordialement,

[Lolo78]

Bonjour,

dans la mesure où tes tokens cmdfile et param sont identiques, tu pourrais en principe encore simplifier (non testé):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
grammar TEST is export {
    rule TOP { <run> <mot> * }
    rule run { '@' <mot> }
    token mot { <[ a..z A..Z 0..9 \-_.!~*'():@&=+$,/\' ]>+ }
}

Mais j'ai dit "en principe" parce qu'il n'est pas sûr que cette simplification soit vraiment souhaitable: si tu découvres plus tard que cmdfile et param ne doivent en définitive pas être complètement identiques, tu devras tout réécrire, alors qu'avec ta solution, la réécriture a des chances d'être bien moins lourde. Et le fait d'utiliser ces deux tokens est en quelque sorte auto-documentée. Du coup, pour éviter tout de même la répétition du motif, tu pourrais aussi opter pour quelque chose de ce genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
grammar TEST is export {
    rule TOP { <run> <params> }
    rule run { '@' <mot> }
    rule params { <mot> * }
    token mot { <[ a..z A..Z 0..9 \-_.!~*'():@&=+$,/\' ]>+ }
}

A voir cependant si on ne pourrait pas simplifier le token mot en considérant que c'est un groupe quelconque de caractères autres que des espaces:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
    token mot { \S+ }

[jeepc]

Effectivement, c'est beaucoup mieux.
Je confirme également que je risque de devoir décomposer cmdfile en path/file. Bref, j'ai encore de quoi à jouer ...

Merci encore pour votre aide qui est très utile et très appréciée.
Bien cordialment,

[Lolo78]

Il est préférable de créer de nouveaux billets plutôt que poster de nouvelles question dans un fil existant ayant un autre objet (présentation d'un tutoriel sur les grammaires Perl 6).

[Lolo78]

Bonsoir,

je viens de faire une mise à jour importante de l'article sur les Regex et les Grammaires de Perl 6, avec en particulier l'ajout d'une grammaire pour la mise en œuvre d'une calculette arithmétique (avec règles de précédence et parenthèses) ainsi que de quelques nouvelles pages relatives à des utilisations avancées des grammaires, notamment:

• La composition de rôles dans une grammaire,
• Les règles nommées de type proto
• Éviter le piège de la récursion gauche

et une multitude d'améliorations de détail.

Si vous avez téléchargé la version antérieure, n'hésitez pas à revenir pour prendre connaissance de cette nouvelle version.

Au total, cette version représente environ une vingtaine de pages de plus que la version d'origine.

Bonne lecture à tous,

Laurent.