URL: https://linuxfr.org/news/raku-en-2020 Title: Raku en 2020 Authors: contra-sh BAud, Davy Defaud, palm123, Bruno Ethvignot, orfenor, Yves Bourguignon, claudex, Ysabeau đŸ§¶, bubarđŸŠ„, BenoĂźt Sibaud, Pierre Jarillon et Adrien Dorsaz Date: 2020ćčŽ11月09æ—„T08:43:44+01:00 License: CC By-SA Tags: raku et rakudo Score: 50 ~~Perl 6~~ Raku est un langage puissant et mature qui fut assez difficile Ă  mettre en Ɠuvre (ce qui sera abordĂ© dans la deuxiĂšme partie de la dĂ©pĂȘche). Raku est nĂ© « Perl 6 », mais n’est pas/plus la prochaine version de Perl 5 (qui sera Perl 5.34 ou Perl 7, voir la dĂ©pĂȘche [annonce de Perl 7](https://linuxfr.org/news/annonce-de-perl-7)). Raku a, d’ailleurs, Ă©tĂ© renommĂ© en 2019 pour clarifier ce positionnement. Raku partage en effet avec Perl 5 : - des caractĂ©ristiques techniques (proche du langage naturel, [sigils](https://fr.m.wikipedia.org/wiki/Sigil_(informatique))...) ; - la mĂȘme fondation ; - les mĂȘmes confĂ©rences ; - en partie leurs communautĂ©s (Damian Conway, Larry Wall...) ; - certains Ă©vĂšnements ([Perl Weekly Challenge](https://perlweeklychallenge.org/)...). ---- [Tester Raku en ligne](https://repl.it/languages/raku) [Raku](https://www.raku.org/) [Rakudo](https://rakudo.org/) [MoarVM](https://www.moarvm.org/) ---- ![Divers goodies Raku](https://i.imgur.com/QUK3Xhn.jpg) # À propos de Raku ## PrĂ©ambule Raku est (devenu) bien trop « diffĂ©rent » de Perl 5. On peut Ă  prĂ©sent dire tout simplement « Perl » pour dĂ©signer Perl 5 ou Perl 7 et on prĂ©fĂ©rera « Raku » en toutes circonstances pour parler de Perl 6. Il fut un temps oĂč la communautĂ© Perl 6 Ă©tait plutĂŽt contre le changement de nom, mais l’opinion gĂ©nĂ©rale a changĂ© et le renommage a pu se faire en douceur entre 2018 et 2019 (voir plus loin pour les dĂ©tails). Vous pouvez suivre l’actualitĂ© du langage en vous abonnant Ă  la newsletter _[Rakudo Weekly News](https://rakudoweekly.blog/)_. Raku possĂšde une petite communautĂ© et quelques « _killer apps_ » : - [Cro](https://cro.services/), une boĂźte Ă  outils pour le Web (applications, services) ; - [Sparrow](https://github.com/melezhik/Sparrow6) un cadriciel d’automatisation, ainsi que ses [modules](http://sparrowhub.io/) ; - son IDE « [Comma](https://commaide.com/) » ; - un (petit) [CPAN](https://modules.raku.org/). Avant d’aller plus loin, voici quelques liens vers des contenus _LinuxFr.org_ autour du mĂȘme sujet : - [dĂ©pĂȘche _LinuxFr.org_ sur la premiĂšre version publique de Raku en 2010](https://linuxfr.org/news/sortie-de-rakudo-star) ; - journal _LinuxFr.org_ « [Perl 6 devient Raku](https://linuxfr.org/users/raum_schiff/journaux/perl6-devient-raku) » ; - journal _LinuxFr.org_ « [BientĂŽt Perl 6 pour NoĂ«l](https://linuxfr.org/users/raum_schiff/journaux/bientot-noel-pour-perl6) ». Une fois n’est pas coutume, parlons un peu de Raku, sa communautĂ© et ses « news » :D. ## Quelques personnalitĂ©s importantes du monde Raku Avant de rentrer plus en dĂ©tail dans le processus de renommage et dans les versions de Raku, mettons Ă  l’honneur quelques personnalitĂ©s du monde Raku : - **Jonathan Worthington** : Lead dĂ©veloppeur actuel de Rakudo ([interview Jonathan Worthington](http://www.josetteorama.com/all-about-perl-6-interview-of-jonathan-worthington-part-1-of-3/)) - **Elizabeth Mattijsen** : trĂšs impliquĂ©e dans Perl 6 ; - **Patrick Michaud** : ancien lead dĂ©veloppeur de Rakudo, NQP, etc. ; - **Audrey Tang** : actuellement ministre du numĂ©rique Ă  TaĂŻwan (!), anciennement dĂ©veloppeuse principale de Pugs (implĂ©mentation de Perl 6 en Haskell, voir [vieille interview](http://www.perlcast.com/2006/03/interview-with-audrey-tang.html) ou encore cette [interview](https://andrewshitov.com/2015/05/05/interview-with-audrey-tang/)) ; - **Damian Conway** : enseignant, orateur, porte‐parole et dĂ©veloppeur prolifique ; - **Larry Wall** : crĂ©ateur de Perl (BDFL) et initiateur de Raku. Plus besoin de le prĂ©senter ! En 2020, plus vraiment impliquĂ© ; - **Moritz Lenz** : Ă©crivain et gros contributeur ; - **Flavio S. Glock** : dĂ©veloppeur principal de Perlito. Tous ne sont pas encore actifs et la liste n’est pas exhaustive ! La communautĂ© Raku a dĂ©cidĂ© rĂ©cemment de mettre en place un [comitĂ© dĂ©cisionnaire](https://github.com/Raku/Raku-Steering-Council/blob/main/announcements/20200720.md). ## Le processus de changement de nom : Perl 6 → Raku Un langage de programmation qui change de nom, ça n’arrive pas souvent ! Il y a peu, Raku a donc fĂȘtĂ© sa premiĂšre annĂ©e (ou ses 21 ans !). Voici comment s’est dĂ©roulĂ© le renommage : 1. Larry Wall a tout d’abord [proposĂ© un alias](https://www.youtube.com/watch?v=E5t8qaAGw9w) ; 2. alias demandĂ© par des personnes de la communautĂ© Perl 6 ; 3. validĂ© ensuite par Larry Ă  la confĂ©rence Raku Ă  Riga ; 4. plus tard, une des membres de la _core team_ (Elizabeth Mattijsen) ouvre un ticket sur le GitHub officiel de Raku pour un renommage : ![Rapport de bogue d’Elizabeth](https://i.imgur.com/HCNbmwF.png) 5. Elizabeth ouvre ensuite une demande d’intĂ©gration sur le dĂ©pĂŽt Git officiel de Raku (avec demande de vote des mainteneurs) : ![Demande d’intĂ©gration Git d’Elizabeth](https://i.imgur.com/IR0XkJB.png) 6. les votes sont positifs (ou des abstentions), puis vient la « bĂ©nĂ©diction » de Larry Wall : ![Commentaire de Larry Wall](https://i.imgur.com/u5AKUiC.png) 7. renommage entĂ©rinĂ©, souhaitons la bienvenue Ă  Raku ! Le processus de renommage en liens : - aoĂ»t 2017 : _[Original idea for Perl 6 Alias](https://www.youtube.com/watch?v=E5t8qaAGw9w)_ ; - octobre 2018 : _[A request to Larry Wall for an alias](https://perl6.party/post/A-Request-to-Larry-Wall-to-Create-a-Language-Name-Alias-for-Perl-6)_ ; - novembre 2018 : _[On Raku](https://liztormato.wordpress.com/2018/11/06/on-raku/)_ ; - aoĂ»t 2019 : _[Liz issue — Perl in the name is confusing](https://github.com/Raku/problem-solving/issues/81)_ ; - aoĂ»t 2019 : _[Liz PR — Path to Raku](https://github.com/Raku/problem-solving/pull/89)_ ; - septembre 2019 : _[On renaming Perl 6](https://andrewshitov.com/2019/09/24/on-renaming-perl-6/)_ ; - octobre 2019 : _[Blessing of Larry then renaming](https://github.com/Raku/problem-solving/pull/89#pullrequestreview-300789072)_. ## Versions de Raku(do) Depuis 2015, l’implĂ©mentation de Raku est « complĂšte » et les travaux autour du compilateur et de la VM sont plus orientĂ©s vers les performances. Raku a connu plusieurs versions officielles (dont la plus « marquante » Ă©tait en 2015) : - premiĂšre version publique de Rakudo * en juillet 2010 (version majeure mais incomplĂšte, encore basĂ©e sur Parrot donc Rakudo + Parrot) ; - 6.c « Christmas » en 2015 ([annonce](https://perl6advent.wordpress.com/2015/12/25/christmas-is-here/)) (Rakudo + MoarVM) ; - 6.d « Diwali » en novembre 2019 ([dĂ©tails des nombreux changements](https://github.com/Raku/roast/blob/master/docs/announce/6.d.md)) (Rakudo + MoarVM) ; - 6.e sera la prochaine version majeure (Rakudo + MoarVM). D’oĂč provient ce schĂ©ma de versions ? Tout simplement d’une blague rĂ©currente sur la date de sortie de Raku. Il Ă©tait coutume de rĂ©pondre « ça sera prĂȘt pour NoĂ«l » comme une blague ou une pirouette :D En plus de ces versions majeures, l’équipe derriĂšre Raku produit des versions mineures mensuelles. ## Quelques livres Avant d’attaquer les dĂ©tails du langage, voici quelques livres qui vous permettront d’en apprendre plus sur Raku : - _[Perl 6 Essentials](https://www.oreilly.com/library/view/perl-6-essentials/0596004990/)_ ; - _[Learning Perl 6](https://www.oreilly.com/library/view/learning-perl-6/9781491977675/)_ ; - _[Think Perl 6](https://www.oreilly.com/library/view/think-perl-6/9781491980545/)_ ; - _[Perl 6 quick syntax reference](https://www.oreilly.com/library/view/perl-6-quick/9781484249567/)_ ; - _[Perl 6 deep dive](https://www.oreilly.com/library/view/perl-6-deep/9781787282049/)_ ; - _[Raku fundamentals](https://www.oreilly.com/library/view/raku-fundamentals/9781484261095/)_. La partie technique commence ici, vous ĂȘtes prĂȘts ? :D ## Les qualitĂ©s intrinsĂšques de Raku On ne se refait pas ! GrĂące aux qualitĂ©s de linguiste de son crĂ©ateur Larry Wall, Raku est trĂšs influencĂ© par le langage naturel. Raku est multi‐paradigmes (procĂ©dural, fonctionnel, programmation concurrente et orientĂ© objet). Comme son cousin Perl 5 : * c’est un langage riche et qui a une notion de « contexte » ; * ses [[expressions rationnelles]] sont trĂšs puissantes et il intĂšgre mĂȘme une gestion des grammaires directement dans le langage ! * il possĂšde un [CPAN](https://modules.raku.org/t/CPAN). Contrairement Ă  lui : * l’interfaçage avec le code natif est trĂšs simple ; * la programmation orientĂ©e objet est native (cadriciel + types objets) ; * le langage est rĂ©sistant Ă  la concurrence ; * Unicode est pris en charge « par dĂ©faut ». Pour des dĂ©tails techniques supplĂ©mentaires, voici le [glossaire de Raku](https://docs.raku.org/language/glossary) mais Ă©galement une [comparaison des fonctionnalitĂ©s entre les compilateurs](http://web.archive.org/web/20150801100611/http://www.perl6.org/compilers/features) (qui donne un bon aperçu des fonctionnalitĂ©s du langage). Dans les prochains paragraphes, les qualitĂ©s/fonctionnalitĂ©s de Raku seront expliquĂ©es plus en dĂ©tail. ### Le typage - Typage graduel (typage dynamique et statique) : ```perl # Dynamique my Cool $var = 42; # Statique my Str $var = "Raku"; ``` - Annotation dans les signatures : ```perl sub ab(Int $a, Int $b) { return $a+$b; }; say ab(1,1); ``` - InfĂ©rence de type - Allomorphs (et Ă©valuation polymorphique) : `IntStr $foo` - Les jonctions : ```perl my $jonction = 1|2|3; $jonction += 4; # jonction maintenant Ă©gale Ă  5|6|7 $jonction += (1&2); # jonction maintenant Ă©gale Ă  (6|7|8)&(7|8|9) ``` - [Sous‐ensembles](https://perl6advent.wordpress.com/2016/12/08/how-to-make-use-and-abuse-perl-6-subsets/) : permet d’étendre les classes isomorphes, servir de contrainte, tout en Ă©tant rĂ©solu Ă  l’utilisation : ```perl subset Even where * %% 2; say 1 ~~ Even; # False ``` - [Coercition](https://fr.wiktionary.org/wiki/coercition) : ```perl sub i-cast(Int() $n) { say $n.^name } ; i-cast "42"; ``` - [Coercition dans les signatures (contraintes)](https://docs.raku.org/type/Signature#Coercion_type) Contrainte + coercition (« je veux un objet chaĂźne et je _caste_ en objet entier ») : ```perl sub f(Int(Str) $want-int, Str() $want-str) { } ; f '10', 10; ``` Ou contrainte conditionnelle (« mon argument doit ĂȘtre objet entier ou objet chaĂźne ») : ```perl sub xyz($n where $_ ~~ Int | Str ) { say +$n } ``` - Types natifs : ```perl my int8 $verysmall = 42; say $verysmall; ``` - Auto‐boxing : conversion automatique de type natif vers les types objets - Auto‐vivification dans les hash/arrays : ```perl my %a; %a{'autovivication'}++; say %a{'autovivication'}; ``` - [Twigils](https://docs.raku.org/language/variables#Twigils) (!) par exemple pour dĂ©finir la portĂ©e des variables - Toute une [collection de conteneurs objet](https://docs.raku.org/language/setbagmix). Voir la [liste de type composites](https://docs.raku.org/type-composite.html) (Keyset, Bag, Map, list, Mix, Pair, Set...) - _Shaped array/hashes_ (en quelque sorte des matrices ou hash multi dimensions...) - Compact arrays : `my int @array` est stockĂ© contigu en natif - [Listes paresseuses](https://medium.com/@jcoterhals/perl-6-small-stuff-5-gather-around-its-time-to-get-lazy-but-why-da20fdb18a3b) (voir Ă©galement `Gather`) : ```perl my @list = (1, 1, * + * ... *).grep({ $_.is-prime }); say @list[4]; # This generates elements 0..4. # Elements 5..∞ haven't been generated yet ``` ### Routines - NommĂ©es (argument) : ```perl sub plus2($foo) { return $foo+2; } ``` - TypĂ©es : ```perl sub mul3(Int $foo) { return $foo*3; } ``` - Avec attribut _rw_ ou _copy_ : ```perl sub make42($foo is rw) { $foo = 42; } ``` - Multi‐dispatch : ```perl multi sub sayit( Int $n ) { say "Number: $n"; } multi sub sayit( Str $s ) { say "String: $s"; } ``` Le dispatch se base sur le nombre d’arguments, les types, les contraintes (on peut mĂȘme en jouer avec les fonctions nextsame, nextwith, callsame, callwith). Voir aussi « _Proper narrowness analysis_ » pour la rĂ©solution du meilleur candidat. - Gobage gourmand des arguments restants et aplatissement des arguments (comme en Perl 5). ### OpĂ©rateurs - Raku possĂšde une grande quantitĂ© d’opĂ©rateurs, voyez plutĂŽt : [![Tableau pĂ©riodique des opĂ©rateurs](https://i.imgur.com/4RmbUaO.jpg)](https://i.imgur.com/4RmbUaO.jpg) - Raku peut ĂȘtre facilement Ă©tendu (voir [doc opĂ©rateurs](https://docs.raku.org/language/operators)) ; - opĂ©rateurs natifs (inline optimisations ou explicite) ; - les opĂ©rateurs peuvent ĂȘtre en UTF‐8 ; - [opĂ©rateurs natifs](https://6guts.wordpress.com/2011/10/15/an-optimizer-lands-bringing-native-operators/). ### Async, parallĂ©lisme et concurrence Une boĂźte Ă  outils plus que complĂšte de fonctionnalitĂ©s pour gĂ©rer l’[asynchrone, le parallĂ©lisme et la concurrence](http://doc.perl6.org/language/concurrency) : - [promises (ou future)](https://docs.raku.org/language/concurrency#Promises) utilisable avec [Proc::Async](https://docs.raku.org/language/concurrency#Proc::Async) pour des appels externes ; - gestion des streams avec [Channel](https://docs.raku.org/language/concurrency#Channels) et [Supplies](https://docs.raku.org/language/concurrency#Supplies) pour implĂ©menter de l’_event driven_ comme des _patterns publish/suscribe_ ; - un accĂšs Ă  des primitives plus bas niveau comme les _[threads, scheduler, locks](https://docs.raku.org/language/concurrency#Low-level_APIs)_. ### Programmation OrientĂ©e Objet et Programmation Meta Objet PossibilitĂ© de dĂ©finir ses propres opĂ©rateurs (vu plus haut) et fonctionnalitĂ©s. La prise en charge du _meta object programming_ est gĂ©rĂ©e en partie dans la machine virtuelle : - hĂ©ritage simple ou multiple ; - introspection ; - [« Ă©diter » une classe aprĂšs instanciation]([exemple](https://gist.github.com/draegtun/276591)) une classe aprĂšs dĂ©claration/instanciation ; - [composer/encapsuler](https://perl6advent.wordpress.com/2011/12/14/meta-programming-what-why-and-how/) des mĂ©thodes ; - [Trust relationship](https://docs.raku.org/type/Metamodel::Trusting) qui permet d’accĂ©der Ă  des mĂ©thodes privĂ©es d’une autre classe (parente) sans les faire rentrer dans l’hĂ©ritage ; - [dĂ©lĂ©gations](https://laurent-rosenfeld.developpez.com/tutoriels/perl/perl6/objets/#L2-6) `has $.base is rw handles ` ; - type _whatever_ « * » (qui a d’ailleurs donnĂ© son nom a la distribution « Rakudo star »). ### Grammaires Une gestion des [grammaires](https://docs.raku.org/language/grammars) (`grammar`, `token`, `rule`, `regex`) dans le langage ! ```perl grammar Calculator { token TOP { } proto rule calc-op {*} rule calc-op:sym { '+' } rule calc-op:sym { '-' } token num { \d+ } } class Calculations { method TOP ($/) { make $.made; } method calc-op:sym ($/) { make [+] $; } method calc-op:sym ($/) { make [-] $; } } say Calculator.parse('2 + 3', actions => Calculations).made; ``` ### Interfaçage La prise en charge du langage natif est vraiment trĂšs facile ! - Interfaçage facile avec les langages natifs (_Native Call_) : ```perl use NativeCall; sub fork() returns int32 is native {}; ``` - Interfaçage avec Perl 5 avec [Inline::Perl5](https://github.com/niner/Inline-Perl5) : ```perl use Inline::Perl5; my $p5 = Inline::Perl5.new; $p5.call('print', 'Hello World'); $p5.use('Test::More'); $p5.call('Test::More::plan', tests => 1); ``` ### Unicode traitĂ© au niveau graphĂšme TrĂšs haut niveau de gestion d’Unicode, notamment grĂące Ă  des primitives dans la machine virtuelle MoarVM. Les opĂ©rateurs du langage eux‐mĂȘmes peuvent ĂȘtre en UTF‐8 (comme ceux que l’on crĂ©e). ### Autres fonctionnalitĂ©s en vrac - _[Pointy arrow block](https://andrewshitov.com/2018/10/31/anonymous-code-blocks-in-perl-6/)_ (closure anonyme) : ```perl my $cube = -> $x {$x ** 3}; say $cube(3); # 27 ``` - [Placeholders](https://andrewshitov.com/2018/10/31/placeholders-in-perl-6/) Par ordre alphabĂ©tique : ```perl my $pow = {$^x ** $^y}; say $pow(3, 4); # 81 ``` Ou alors : ```perl for 0..9 { say "$^n2, $^n1"; } ``` Ou avec nommage : ```perl my $pow = {$:base ** $:exp}; say $pow(:base(25), :exp(2)); # 625 ``` # Compilateurs, cadriciels et machines virtuelles Dans cette seconde partie, nous allons dĂ©tailler les mises en Ɠuvre du langage Raku. PrĂ©parez‐vous, les acronymes arrivent ! ![Lettre de scrabble](https://i.imgur.com/BcmmJHv.jpg) _Licence Creative Commons CC0 1.0_ ## Quelle implĂ©mentation « officielle » ? RĂ©ponse courte : **Rakudo et MoarVM**. Au dĂ©part il fut dĂ©cidĂ© qu’aucune implĂ©mentation ne serait dĂ©finie comme « officielle » pour Raku mais plutĂŽt que « Raku est quelque chose qui rĂ©ussit la [suite de tests officiels](https://github.com/Raku/roast) ». En rĂ©alitĂ©, depuis 2012, il existe une implĂ©mentation officielle _de facto_ qui est **Rakudo + MoarVM**. Avant ça, il y eut le cadriciel Parrot (2002 - 2012) ainsi que Pugs (2005 - 2007) ou encore divers autres compilateurs et environnements d’exĂ©cution (Mildew, Niecza, Yapsi...). Cette partie technique et historique sera abordĂ©e en fin de dĂ©pĂȘche. Mais revenons en arriĂšre pour parler des dĂ©buts. La toute premiĂšre annonce de la crĂ©ation de Raku date du 19 juillet 2000. L’idĂ©e de Larry Wall Ă©tait d’en faire un projet ultra communautaire jusque dans la conception du langage, et il commencera donc par demander de contribuer aux spĂ©cifications. Il en dĂ©coulera en tout 361 [RFC](https://raku.org/archive/rfc/), dont Larry wall produira des [apocalypses](https://raku.org/archive/doc/apocalypse.html) qui seront expliquĂ©es ensuite par Damian Conway dans les [exĂ©gĂšses](https://raku.org/archive/doc/exegesis.html) puis encore dĂ©taillĂ©es dans les [synopses](https://design.raku.org/). ![RFC Apocalypses Synopses](https://i.imgur.com/mPDPNaI.png) Des liens pour les historiens ou les curieux : - 2000 - 1018 : le dĂ©pĂŽt [Raku museum](https://github.com/Raku/museum-items) sauvegarde partiellement les « Ă©vĂ©nements » qui font partie de l’histoire de Raku ; - 2000 : [Vieil article de blog critiquant le processus de RFC (au dĂ©but)](https://www.perl.com/pub/2000/11/perl6rfc.html/) ; - 2005 : [Get involved in Pugs](https://www.perlmonks.org/?node_id=455979) ; - 2006 : [Get involved in Perl 6](https://www.perlmonks.org/?node_id=628746) ; - 2008 : [Get involved in Perl 6](https://www.perlmonks.org/?node_id=690945) ; - 2009 : [Get involved in Perl 6](https://www.perlmonks.org/?node_id=771635) ; - 2015 : [Entretien Flavio Glock](https://andrewshitov.com/2015/05/15/interview-with-flavio-glock/). # Parrot CrĂ©Ă©s en [2002](https://github.com/parrot/parrot/blob/master/docs/parrothist.pod), le cadriciel et la [machine virtuelle Parrot](http://docs.parrot.org/parrot/latest/html) ont longtemps Ă©tĂ© au centre de l’implĂ©mentation de Raku (ce n’est plus le cas aujourd’hui). Parrot est nĂ© d’un poisson d’avril annonçant l’unification de Perl et Python et mĂȘme la sortie prochaine d’un livre sur le sujet : ![Annonce de l’unification de Perl et Python](https://i.imgur.com/L0B08KB.gif) Pourquoi construire une *nouvelle* VM ? La JVM fut Ă©tudiĂ©e en 2001, mais jugĂ©e peu adaptĂ©e aux langages dynamiques (elle ne l’était d’ailleurs toujours pas en 2010, _quid_ de 2020 ?). ## Compilation Parrot offre bien plus d’une machine virtuelle, Parrot est un cadriciel de crĂ©ation, compilation et exĂ©cution de langage. Ce cadriciel permet de construire facilement et rapidement des langages de haut niveau (HLL). Il a Ă©tĂ© mis en pratique par Rakudo pendant longtemps. ### PCT PCT signifie _Parrot Compiler Tools_. Son but est de permettre la crĂ©ation de compilateur et d’environnement d’exĂ©cution de langages de haut niveau (HLL). ![PCT](https://i.imgur.com/5SBLZLB.png) PCT est Ă©crit en PIR (voir plus loin section assemblage). ### PAST PAST signifie _Parrot Abstract Syntax Tree_ : reprĂ©sentation interne d’un arbre syntaxique. ### HLL HLL signifie _High Level Language_. ### PGE Au dĂ©part appelĂ© P6GE, **PGE** signifie _Perl Grammar Engine_. Se base sur **HLLCompiler**. Une rĂšgle PGE ressemble Ă  ça : ```perl rule term { | \( \) } rule number { \d+ } rule expr { ( '+' )* } ``` PGE Ă©tait utilisĂ© par Pugs, un autre compilateur Raku (voir plus loin). ### TGE TGE signifie _Tree Grammar Engine_. ### PACT [PACT](https://github.com/parrot/PACT) signifie _Parrot Alternate Compiler Toolkit_. Une alternative Ă  PCT qui Ă©tait considĂ©rĂ© comme trop limitĂ©. ## Assemblage ### PASM PASM signifie _Parrot assembly language_ (PASM). Le code bas niveau prĂȘt Ă  ĂȘtre converti et exĂ©cutĂ© par Parrot VM. Du code PASM ressemble Ă  ça : ```asm set I1, 1 REDO: gt I1, 10, END print I1 print " " inc I1 branch REDO END: print "\n" end ``` RĂ©fĂ©rences : - [exemples de code PASM](http://www.parrot.org/dev/examples/pasm) ; - articles LinuxMag des mongueurs FR sur l’écriture d’assembleur Parrot : [1](http://articles.mongueurs.net/magazines/linuxmag97.html), [2](http://articles.mongueurs.net/magazines/linuxmag98.html) et [3](http://articles.mongueurs.net/magazines/linuxmag99.html). ### IMCC IMCC signifie _Intermediate Code Compiler_. C’est un outil alternatif pour crĂ©er et exĂ©cuter du _bytecode_ Parrot. IMCC apporte son propre langage, communĂ©ment appelĂ© _Parrot Intermediate Language_ (PIR). IMCC embarque le l’environnement d’exĂ©cution Parrot, donc IMCC peut compiler du PIR vers PASM, puis du PASM vers PBC, puis exĂ©cuter ce _bytecode_. IMCC peut Ă©galement faire des optimisations, mĂȘme s’il ne le fait pas par dĂ©faut. ### PIR D’abord appelĂ© IMC, [PIR](http://docs.parrot.org/parrot/latest/html/docs/user/pir/intro.pod.html) est une surcouche de PASM sans ĂȘtre pour autant un langage de haut niveau. Les fichiers contenant du code PIR portent le suffixe « .imc » Voici Ă  quoi ressemble PIR : ```asm .sub loopy .local int counter counter = 0 LOOP: if counter> 10 goto DONE print counter print " " inc counter goto LOOP DONE: print "\n" end .end ``` Vous pouvez en apprendre plus grĂące Ă  cette [intro IMCC](https://www.oreilly.com/library/view/perl-6-essentials/0596004990/ch07.html) ou cet article sur comment [Ă©crire du PIR](http://docs.parrot.org/parrot/latest/html/docs/user/pir/intro.pod.html). Voir ici des [exemples PIR](http://www.parrot.org/dev/examples/pir) ou encore la [documentation dĂ©taillĂ©e des mongueurs FR sur PIR](http://articles.mongueurs.net/magazines/linuxmag122.html). ## ExĂ©cution ### NCI NCI signifie _Native Call Interface_. ### PMC PMC signifie _PolyMorphic Container_ ou _Parrot Magic Cookies_ (la façon de reprĂ©senter les donnĂ©es dans la machine virtuelle). ### PBC BC signife Parrot Byte Code ## La VM Parrot La VM Parrot est une machine virtuelle Ă  base de registre, ce qui n’est pas la « norme » (par exemple JVM). Voici quelques fonctionnalitĂ©s de la VM Parrot : - capable de gĂ©rer les langages statiques et dynamiques ; - _Copy On Write_ ; - gĂšre les continuations et closures ; - peut ĂȘtre embarquĂ© dans du code C ; - _PolyMorphic Container_ (souplesse du stockage des types). Il est facile d’inclure Parrot dans du code C ou d’appeler du C dans Parrot (_[Native Call Interface](http://docs.parrot.org/parrot/latest/html/docs/pdds/draft/pdd16_native_call.pod.html)_). ## ImplĂ©mentation Raku basĂ©e sur Parrot (2002 - 2012) ![PCT IMCC ParrotVM](https://i.imgur.com/OiSnp6E.png) Ou avec une Ă©tape IMCC et Parrot fusionnĂ©e (plus tard car IMCC contient Parrot) : ![PCT IMCC](https://i.imgur.com/vmnqyof.png) Ci‐dessous un schĂ©ma encore plus dĂ©taillĂ©/technique (tirĂ© d’une documentation Parrot) : ![Fonctionnement de Parrot](https://i.imgur.com/o863GWT.png) De nombreux dĂ©tails sont disponibles dans le _[Parrot Design Document](http://docs.parrot.org/parrot/latest/html/pdds.html)_. ## ProblĂšmes avec Parrot Si au dĂ©part Parrot Ă©tait au centre de Raku, cela a changĂ© au cours du temps : - 2008 : « _While Parrot is the most solid solution to deploy Perl 6 in the long term, on the other hand, the challenges Parrot has accepted had proven to consume more time and resources than previously expected._ » ([_Perl foundation news_](https://news.perlfoundation.org/post/2008q2_grant_proposal_smop_sim)) ; - 2013 : « _The latest news is that Parrot Virtual Machine is no longer the only one enjoying Rakudo’s exclusivity._ » (_[all about Perl 6](http://www.josetteorama.com/all-about-perl-6-interview-of-jonathan-worthington-part-1-of-3/)_) ; - des problĂšmes de communication ; - Parrot s’est petit Ă  petit Ă©loignĂ© de Perl 6 (en devenant plus gĂ©nĂ©raliste). Petit Ă  petit, le compilateur Rakudo s’est Ă©mancipĂ© de Parrot et cible Ă  prĂ©sent une nouvelle machine virtuelle. # Rakudo Star (Ă  partir de 2010) La premiĂšre version majeure de Rakudo Star (ou « Rakudo * ») se basait sur Parrot (PCT + ParrotVM), mais nous passerons sous silence cette version pour nous concentrer sur l’implĂ©mentation actuelle (Rakudo + MoarVM). ## Compilation (Rakudo) **Rakudo** est un compilateur pour Raku qui implĂ©mente la totalitĂ© du langage et peut cibler plusieurs diffĂ©rentes VM (la principale Ă©tant MoarVM). La majeure partie de Rakudo est Ă©crite en Raku simplifiĂ© (NQP). Rakudo implĂ©mente Ă©galement la prĂ©compilation pour optimiser ses performances. En plus de ça, Rakudo amĂ©liore l’arbre syntaxique Ă  l’aide de plusieurs mĂ©thodes d’optimisations dont voici quelques exemples : - les itĂ©rations _range_ converties sont en boucles natives ; - dé‐virtualisation de mĂ©thodes privĂ©es avec rĂ©solution Ă  la compilation ; - suppression de code (statiquement) mort ; - anonymiser une variable ; - rĂ©duire la portĂ©e d’une variable ; - dĂ©pliage des jonctions. ### NQP [NQP](https://github.com/Raku/nqp) est un compilateur comme MiniPerl pour Perl 5. C’est un outil de _bootstrapping_ qui aide Ă  compiler les parties en Raku de Rakudo) et compiler les bibliothĂšques avant d’avoir compilĂ© les bibliothĂšques. Contrairement Ă  MiniPerl pour Perl 5 (qui est un interprĂ©teur sans toutes les piles : c’est‐à‐dire sans les modules mĂ©langeant code Perl et code natif), NQP ne sait compiler qu’un « Raku simplifiĂ© ». NQP designe aussi bien le compilateur que le code source contenu dans des fichiers portant l’extension « .nqp ». Du code NQP ressemble Ă  ça : ```perl method symtable() { %!symbol := nqp::hash() if nqp::isnull(%!symbol); %!symbol } method evaluate_unquotes(@unquotes) { my $result := self.shallow_clone(); my $i := 0; my $elems := nqp::elems(@(self)); while $i < $elems { $result[$i] := self[$i].evaluate_unquotes(@unquotes); $i := $i + 1; } $result } ``` NQP fait partie de Rakudo et semble avoir Ă©tĂ© inspirĂ© par MiniPerl6/KindaPerl6. ## ExĂ©cution (MoarVM) [MoarVM](https://github.com/MoarVM/MoarVM) signifie _Metamodel On A Runtime VM_ ([site officiel](https://www.moarvm.org/index.html)). C’est une machine virtuelle basĂ©e sur les registres comme Parrot. [Jonathan Worthington](https://github.com/jnthn) est le fondateur et architecte de MoarVM. Voici quelques caractĂ©ristiques de MoarVM : - reprĂ©sentation interne plus proche de Raku (par rapport Ă  Parrot) (« _On the other hand, there are features that are hard to implement efficiently if the VM doesn’t support it._ », d’aprĂšs une [interview de Flavio Glock](https://andrewshitov.com/2015/05/15/interview-with-flavio-glock/)) ; - superbe gestion d’Unicode, avec les chaĂźnes de caractĂšres reprĂ©sentĂ©es au niveau graphĂšme ; - gestion de la programmation asynchrone et concurrente avec des structures de contrĂŽles pour la programmation concurrente, les sockets synchrones, minuteurs, processus, sĂ©maphores, files bloquantes, etc. - ramasse‐miettes prĂ©cis, gĂ©nĂ©rationnel (jeunes → [_semispace_](http://www.cs.cornell.edu/courses/cs312/2003fa/lectures/sec24.htm) et vieux → gros _buckets_) et gĂ©rant la concurrence ; - capable de gĂ©rer les continuations ; - _[bounded serialization](https://6guts.wordpress.com/2012/02/10/bounded-serialization-better-regexes-and-better-errors/)_, sĂ©rialiser le code des modules chargĂ©s pour plus tard et gagner du temps de dĂ©marrage en Ă©vitant de reconstruire les reprĂ©sentations intermĂ©diaires de ce code ; - _runtime loading of code_ ; - optimisations : _tail call_ Ă©liminations (ne pas empiler dans la pile d’appel si le retour de fonction est dans l’appel), _dispatch_, Ă©limination de code mort, _on stack replacement_ (remplacement sur la pile de routine non optimisĂ©e par une routine optimisĂ©e), _[escape analysis](https://en.wikipedia.org/wiki/Escape_analysis)_ (transformer des allocations de tas en allocation sur la pile ou mĂȘme dans un registre) et _scalar replacement_ (Ă©limine des allocations mĂ©moire) ; - JIT compilation ; - profilage de la pile d’appel et des allocations ; - [heap snapshotting](https://6guts.wordpress.com/2016/03/21/a-whole-heap-of-work/) V : principalement pour analyses ultĂ©rieures (investigation et amĂ©lioration du ramasse‐miettes, par exemple). Je conseille Ă©galement la lecture de cette [introduction de MoarVM](http://brrt-to-the-future.blogspot.com/2014/05/moarvm-as-machine.html). ### MAST MAST signifie _MoarVM AST_ (arbre de syntaxe abstraite). ### MBC MBC signifie _MoarVM Byte Code_. Voici Ă  quoi ressemble MBC : ```asm ; Grab value out of Scalar decont r4, r1 ; Grab type ; de-Scalar if needed wval r5, 1, 34 decont r3, r5 ; Ensure arg is an Int istype r6, r4, r3 assertparamcheck r6 ``` ## ImplĂ©mentation basĂ©e sur Rakudo + MoarVM (depuis 2012) MoarVM ne possĂšde pas d’assembleur. ![Rakudo Moar](https://i.imgur.com/y6LcX0W.png) Ci‐dessous un autre schĂ©ma d’architecture tirĂ© d’une prĂ©sentation sur les optimisations Rakudo/MoarVM (2014) : ![Architecture Rakudo](https://i.imgur.com/vv8qbgf.png) # Pugs (2005 - 2007) À partir d’ici on commence l’archĂ©ologie, la vraie. Dans sa courte existence, Pugs a explorĂ© de nombreux choix d’architecture. Pugs dĂ©signe l’interprĂ©teur, le compilateur, l’environnement d’exĂ©cution et la suite de tests. Le compilateur peut compiler en Haskell, JavaScript, Perl 5 ou PIR (pour Parrot, donc, si vous vous souvenez). ![Pusg compilation flow](https://i.imgur.com/GrTsEEN.png) Pugs est Ă©crit en Haskell et tombe en sommeil aprĂšs 2007. ## Compilation Voici les notions de compilations autour de l’implĂ©mentation Pugs. ### PCR PCR signifie _Pugs Compiler Rules_. C’est une implĂ©mentation en Perl 5 du moteur d’expressions rationnelles de Raku. PCR a remplacĂ© PGE dans Pugs. ### LREP LREP a Ă©voluĂ© en _Pugs::Compiler_, puis, plus tard, MiniPerl6. ### Pugs::Compiler _Pugs::Compiler_ est un ensemble de modules Perl 5 pour compiler Raku. ### MiniPerl6 Faisait partie de Pugs mais dans un rĂ©pertoire sĂ©parĂ©. **MiniPerl6** est devenu **KindaPerl6** puis **Perlito6**. ### KindaPerl6 KindaPerl6 ou KP6 est une implĂ©mentation Raku de la grammaire en Raku avec un _bootstrap_ en Perl 5. KindaPerl6 est construit Ă  partir de MiniPerl6. ## ExĂ©cution ### PIL PIL signifie _Pugs Intermediate Langage_. PIL n’est pas un format lisible par les humains mais plutĂŽt un arbre syntaxique abstrait interne Ă  Pugs. ### PIL-Run ![Pugs PIL Perl](https://i.imgur.com/fTVodd4.png) PIL-Run a Ă©tĂ© construit sur un ensemble de modules Perl 5 qui lisent et exĂ©cutent PIL. PIL-Run Ă©tait le _back‐end_ en Perl 5 de Pugs... au dĂ©but. ## ImplĂ©mentations basĂ©es sur Pugs ### Pugs + back‐ends variĂ©s « Pugs compile et exĂ©cute » ![Pugs compile et exĂ©cute](https://i.imgur.com/w9XpwsZ.png) « Pugs compile pour Parrot (PIR) » ![Pugs PIR](https://i.imgur.com/q3WPTXQ.png) La compilation vers PIR se fait en deux temps, petit zoom dessus : ![Pugs PIL PIR](https://i.imgur.com/DRz7QLB.png) « Pugs compile (transpile ?) vers du JavaScript » ![Pugs JS](https://i.imgur.com/DnSkNSS.png) « Perl compile (transpile ?) vers du Perl 5 » ![Pugs Perl 5](https://i.imgur.com/J75BYSV.png) ### v6 **v6-pugs** puis **v6-alpha** et Ă  prĂ©sent [v6.pm](https://metacpan.org/pod/v6) est une rĂ©Ă©criture complĂšte de Pugs, utilisant un mĂ©lange de Raku (_Pugs::Compiler_ et les modules associĂ©s) et Perl 5. Il rĂ©utilise du code de l’environnement d’exĂ©cution de PIL-Run et « la moitiĂ© du CPAN ». À prĂ©sent v6 est distribuĂ© dans Perlito6. v6.pm est le frontal de Perlito et Pugs en Perl 5. ### Perlito Le projet [Perlito](https://github.com/fglock/Perlito) est menĂ© par [Flavio S. Glock](https://github.com/fglock). Le projet Perlito contient en fait plusieurs compilateurs pour plusieurs langages dans plusieurs langages ciblant des _back‐ends_ variĂ©s : - compiler du Perl 5 vers du code source Java ; - exĂ©cuter du Perl 5 directement dans la JVM ; - compiler du Perl 5 vers du code source JavaScript, exĂ©cute Perl 5 directement dans le navigateur ou Node.js ; - compiler du Raku vers du code source JavaScript, exĂ©cute Perl 6 directement dans le navigateur ou Node.js ; - compiler du Perl 5 vers Perl 5 ; - compiler du Raku vers Perl 5 ; - compiler du Raku vers Python 2.6 ; - compiler du Perl 5 vers Perl 6 (en cours) ; - compiler du Raku vers Ruby 1.9 (en cours) ; - compiler du Raku vers Go (en cours) ; - compiler du Raku vers Common Lisp (SBCL) (en cours). Une chose qu’il ne sait pas faire, c’est traduire du Perl 5 en Raku. MiniPerl6 et KindaPerl6 forment Perlito6. Perlito5 est un portage de Perlito6 en Perl 5. C’est « Perl 5 implĂ©mentĂ© en Perl 5 ». Perlito5 lui‐mĂȘme est Ă©crit en Perl. Perlito6, quant Ă  lui, est Ă©crit en Raku. Perlito implĂ©mente seulement un sous‐ensemble de Raku nommĂ© le « sous‐ensemble utile » et qui : - nÊŒa pas de contexte de liste ; - nÊŒa pas d’hĂ©ritage ; - nÊŒa pas de paresse ; - a des closures mais pas de coroutines ou de continuations ; - nÊŒa pas de multis. # Autres compilateurs, environnements d’exĂ©cution et machines virtuelles Dans cette partie, nous allons continuer notre tour des initiatives autour des compilateurs, environnements d’exĂ©cution et machines virtuelles historiques. ## STD et viv [STD et viv](https://raku.org/compilers/std-viv) sont des Ɠuvres de Larry Wall. On trouve dans [STD](https://github.com/perl6/std/blob/master/STD.pm6) la grammaire de Raku... Ă©crite en Raku (qui n’avait pas de compilateur Ă  l’époque ! C’est le dĂ©but des problĂšmes de _bootstrapping_ :D). [VIV](https://github.com/perl6/std/blob/master/viv) ou littĂ©ralement en chiffres romains « VI → V » (et donc « 6 vers 5 ») Ă©tait un module capable de convertir du Perl 6 vers du Perl 5. ## SMOP D’abord appelĂ© YAP6, **SMOP** signifie _Simple Meta Object Programming_. SMOP est un compilateur et environnement d’exĂ©cution Ă©crit en C pour Raku, mais on dit parfois SMOP pour dĂ©signer seulement l’environnement d’exĂ©cution (qui peut ĂȘtre ciblĂ© par d’autres compilateurs). ![SMOP YAP6](https://i.imgur.com/O4g7su0.png) SMOP n’est pas une machine virtuelle mais un environnement d’exĂ©cution qui ressemble Ă  celui de Perl 5, tout en possĂ©dant des fonctionnalitĂ©s pour gĂ©rer Raku. ## Mildew Mildew Ă©tait un compilateur STD vers SMOP ![Mildew SMOP](https://i.imgur.com/jzARh1J.png) Il utilise directement la grammaire STD. ## Elf Elf Ă©tait un compilateur Ă©crit en Raku avec une grammaire en Ruby. Il pouvait Ă©mettre du Perl 5 ou du Lisp. Il n’a jamais Ă©tĂ© complĂ©tĂ©. Il Ă©tait prĂ©vu qu’Elf puisse cibler SMOP. ## Ponie [Ponie](http://www.poniecode.org/) signifie _Perl On a New Internal Engine_. Il s’agissait de faire tourner Perl 5 dans la machine virtuelle Parrot. ArrĂȘtĂ© en 2006. ![Ponie](https://i.imgur.com/FgBfPvG.png) ## Punie [Punie](https://en.wikipedia.org/wiki/Punie) (rĂ©fĂ©rence directe Ă  Ponie) Ă©tait un compilateur Perl 1 vers Parrot. ## Yapsi [Yapsi](https://github.com/masak/yapsi) pour _Yet Another Perl Six Implementation_ est une implĂ©mentation du compilateur et de ses environnements d’exĂ©cution et machines virtuelles Raku en Raku. ![Yapsi](https://i.imgur.com/9tJYGBB.png) **SIC** signifie _(S??) Instruction Code_, c’est du _byte code_ propre Ă  Yapsi. ## Niecza [Niecza](https://github.com/sorear/niecza) est un compilateur Raku Ă©crit en C# qui cible CLR ([Mono](https://wiki.winehq.org/Mono)). ![Niecza Mono](https://i.imgur.com/xb46ad0.png) Ouf ! C’était le dernier, on a fini. :) # Conclusion AprĂšs une longue pĂ©riode de gestation, le langage Raku est Ă  prĂ©sent complet et mature et a donc Ă©tĂ© publiĂ©. Raku fait preuve d’une grande expressivitĂ© et d’une grande puissance. On trouve de nombreux concepts intĂ©ressants dans Raku comme dans son histoire et celle de ses implĂ©mentations (mĂȘme si la plupart font partie d’un monde disparu) qui mĂ©ritaient qu’on s’y penche un peu. J’espĂšre que cette dĂ©pĂȘche aura su lever le brouillard autour des mĂ©andres d’implĂ©mentations de Raku et mettre en valeur les concepts du langage.

AltStyle ă«ă‚ˆăŁăŠć€‰æ›ă•ă‚ŒăŸăƒšăƒŒă‚ž (->ă‚ȘăƒȘă‚žăƒŠăƒ«) /