<page> <title>Perl 6</title> <id>896854</id> <revision> <id>31741392</id> <timestamp>2008-07-20T20:31:29Z</timestamp> <contributor> <username>Sylphe</username> <id>1354</id> </contributor> <minor /> <comment>Correction d'une faute de frappe</comment> <text xml:space="preserve">{{à mettre à jour}} {{Infobox Langage de programmation | nom = Perl 6 | logo = | paradigmes = [[Programmation orientée objet|Objet]], [[Programmation impérative|impératif]], [[Programmation fonctionnelle|fonctionnel]] | année = [[Spécification (informatique)|Spécification]] : 2001-2008, mise en œuvre partielle par [[NQP]] | auteur = [[Larry Wall]] | développeurs = [[The Perl Foundation]] | dernière version = | typage = [[Typage fort|Fort]], [[Typage dynamique|dynamique]] | implémentations = [[Pugs]], [[Parrot (machine virtuelle)|Parrot]] | dialectes = | influencé par = [[Perl (langage)|Perl]], [[Haskell]], [[APL (langage)|APL]], [[Ruby]], [[Python (langage)|Python]], [[SmallTalk]], [[Self (langage)|Self]] | a influencé = | système d'exploitation = [[Multi-plate-forme]] | licences = | site web = http://dev.perl.org/perl6 }} '''Perl 6''' est une refonte totale du [[langage de programmation]] [[Perl (langage)|Perl]]. <br>Cette refonte garde l'esprit du langage qui laisse une grande liberté au programmeur et lui permet une expression concise. <br>Perl 6 reste un langage générique et permet toujours de programmer des [[uniligne]]s mais propose un bien meilleur support pour l'écriture de programmes importants. <!-- reformulation necessaire: notamment grâce à la possibilité de [[typage statique]] et une [[Interface de programmation|interface]] plus propre au [[langage C]]. --> <br>Le langage de documentation, [[Plain Old Documentation|Pod]], un [[langage de balisage léger]] a été amélioré et mieux intégré pour permettre la [[programmation lettrée]]. Perl 6 n'a pas pour objectif premier d'avoir une [[compatibilité descendante]] avec Perl 5, même s'il y aura un [[mode de compatibilité]] et la possibilité d'appeler les [[module (programmation)|module]]s des [[Paquet (logiciel)|paquetage]]s existants de [[CPAN]]. <br>La [[Spécification (informatique)|spécification]] du langage est pratiquement terminée. Durant les derniers mois de 2006, avec la disponibilité de l'[[interpréteur]] expérimental [[pugs]], cette spécification a eu lieu en parallèle avec l'écriture de jeux de [[test unitaire|tests]] et de [[bibliothèques logicielles]], ce qui a permis son affinement. En 2008, NQP (Not Quite Perl), un programme Parrot écrit en assembleur PIR implante un sous-ensemble conséquent de Perl6 à fin de bootstrapper le langage. <br>Le langage permet toujours d'écrire des programmes très concis, notamment avec le support d'''hyperopérateurs'' similaires aux opérateurs de manipulation de tableaux dynamiques du langage [[APL (langage)|APL]]. C'est un des aspects de la [[syntaxe concrète]] qui permet de [[Calcul parallèle|paralléliser]] l'exécution de portions de programmes. Le langage est complexe mais il est toujours possible de programmer dans un sous-ensemble restreint du langage. Il inclut beaucoup de fonctionnalités qui, pour d'autres langages, appartiennent généralement à des bibliothèques logicielles. Ainsi le système d'[[expression rationnelle|expressions rationnelles]] a été entièrement refondu et constitue aussi un moteur d'[[analyse syntaxique]] puissant et rapide grâce à un contrôle très fin du [[retour sur trace]]. <br>Il est complètement intégré au système objet. <br>Le système objet, mimimaliste en Perl 5, supporte maintenant le [[dispatch multiple]], les [[trait (type abstrait)|rôles]] et la [[réflexion (informatique)|réflexion]]. <br>La [[programmation orientée prototype]] et la [[programmation orientée objet]] sont toutes deux possibles car le programmeur peut modifier le comportement par défaut des [[métaclasse]]s et du mécanisme de dispatch vers les méthodes et multiméthodes. Les rôles sont un système de composition de code similaire aux [[mixin]] mais de granularité inférieure à la [[classe (informatique)|classe]]. Les concepteurs de Perl 6 ont apporté un soin tout particulier à la syntaxe du langage qui avait été notablement alourdie en Perl 5 avec l'ajout du support des [[Référence (informatique)|référence]]s. Les principes directeurs dans la conception du langage sont : le [[principe de Huffman]], la lisibilité, l'extensibilité. Chaque aspect du langage est hautement paramétrable via des constructions lexicales ou syntaxiques appelés adverbes ou modificateurs. Certains [[opérateur (informatique)|opérateur]]s sont des caractères [[Unicode]] mais souvent un alias plus verbeux en [[ASCII]] est disponible. L'interopérabilité avec les bibliothèques d'autres [[langage de haut niveau|langages dynamiques de haut niveau]] est un but à terme grâce à la mise en œuvre de ces langages par le même moteur (Pugs ou [[Parrot]]). Le typage explicite du contenu d'une variable est optionnel. Le typage des données est donc [[typage statique|statique]] lorsqu'il est explicite ou [[inférence de types|inferré]], [[typage dynamique|dynamique]] sinon. <br>Le programmeur dispose donc d'un continuum entre la programmation lâche typique des [[langage de script|langages de script]] et la rectitude et les performances d'un langage à typage statique. Typiquement, un programme évoluera au cours du temps vers un typage plus "serré". Perl 6 devrait être un langage rapide car, outre le typage statique, le support de la parallélisation, ses implantations supportent la [[compilation à la volée]] en [[code natif]]. === Pourquoi Perl6 ? === Le langage Perl était au départ très modeste et a grossi en respectant la compatibilité ascendante. En 18 ans d'évolution, il a accumulé beaucoup de scories qui rendent son apprentissage difficile et complexifient inutilement l'interpréteur. Il fallait s'en débarrasser. Les comportements par défaut du langage étaient conçus pour des programmes de quelques lignes. Même si le langage avait évolué ([[Portée lexicale|variables lexicales]], orientation objet...) pour supporter de gros programmes, une grande partie des programmeurs n'avaient pas adapté leur style, ce qui a donné à Perl une réputation de langage sale. L'interpréteur de Perl 5 n'utilise pas au mieux les architectures multiprocesseurs ou [[microprocesseur multi cœur|multi cœur]] dont la mémoire est lente par rapport au processeur. De plus, pour la programmation en grand, il est nécessaire d'avoir un système puissant de passage de paramètres. De même il était important de donner la possibilité au programmeur, mais non l'obligation, d'un typage statique des données. Ce typage constitue à la fois une documentation, une forme d'assertion exécutée à la compilation et une amélioration des performances par rapport au typage dynamique. Finalement, l'inférence de type sera possible à terme. == Historique == Le processus de conception de Perl 6 a été annoncé pour la première fois le 19 Juillet 2000, par Larry Wall le 4° jour de la conférence annuelle [[OSCON]] dans son discours sur l'état de l'oignon 2000 ("State of the Onion 2000"). A cette date, les principaux objectifs étaient de débarrasser le langage de verrues historiques ("historical warts"); “les choses faciles doivent rester faciles, les choses difficiles doivent être plus faciles, et les choses impossibles ne devraient pas être difficiles†de nettoyer d'une manière générale la conception interne et les APIs. Le processus a commencé avec une série de demandes de changements ou « RFC ». Ce processus était ouvert à tous les contributeurs et ne laissait aucun aspect du langage à l’abri du changement. Une fois le processus des RFC terminé, Wall a revu et classé chaque demande. Il a alors commencé la rédaction des Apocalypses. Bien que le but initial était d’écrire une Apocalypse pour chaque chapitre de « Programmation en Perl », il est devenu évident à la rédaction de chacun des Apocalypses que les précédents apocalypses devenaient invalides de part les derniers changements. Pour cette raison, un ensemble de synopses ont été publiés, chacun relatifs au contenu d’un Apocalypse, mais mis à jour suivant les modifications apparues. Aujourd’hui, les spécifications de Perl 6 continuent presque entièrement à travers les Synopses. Il y a 3 méthodes principales de communication utilisées dans le développement de Perl 6 actuellement. La première est le canal [[Internet Relay Chat|IRC]] #perl6 sur [[Freenode|irc.freenode.net]]. La seconde est un ensemble de listes de diffusion sur les serveurs de la Fondation Perl du domaine perl.org. La troisième est le référentiel de code source [[Subversion (logiciel)|Subversion]] utilisé par l’équipe du projet Pugs. Au fil des ans, Perl 6 à connu plusieurs changements de direction. L’introduction de concepts provenant de [[Python (langage)|Python]] et [[Ruby]] ont influé au début, mais lors de l’écriture de l’interpréteur pugs dans le langage [[Haskell]], on a pu noter une large influence de la programmation fonctionnelle sur l’équipe de conception de Perl 6. == Mises en œuvre == On s'attend à plusieurs mises en œuvre de Perl 6. [[Pugs]] est historiquement la première [[mise en œuvre]] expérimentale de Perl 6. Pugs a été écrit en [[Haskell]]. Pugs peut exécuter du code Perl 6 directement, ainsi que compiler du Perl 6 vers du [[JavaScript]], du [[Perl (langage)|Perl 5]] ou du [[bytecode]] Parrot. Pugs a servi à affiner les specifications de Perl 6. Ecrit essentiellement par Audrey Tang, maintenant peu active. Pugs utilise des fonctionnalités avancées de Haskell, ce qui est un obstacle à la reprise du projet par d'autres programmeurs. Il semble maintenant que le compilateur [[rakudo]] de Parrot sera la première mise en œuvre de Perl 6. Pour le [[bootstrap (compilateur)|bootstrap]] de Perl 6, Parrot utilise NQP (Not Quite Perl), un sous-ensemble de Perl 6 avec [[Parser Grammar Engine|PGE]] pour l'analyse de sa grammaire. Après cela, Perl 6 sera probablement [[auto-hébergement|auto-hébergé]] — il sera utilisé pour se compiler lui-même. Une grande partie de la mise en œuvre de Perl sera alors exposée, rendant possible, par exemple, l'expansion de l'analyseur de code. == Principaux changements depuis Perl 5 == Perl 6 garde l'esprit de Perl 5. La plupart des changements apportés ont pour but de rendre le langage plus homogène, d'intégrer de nouvelles fonctionnalités et de mieux exploiter les architectures matérielles modernes. Les nouvelles fonctionnalités sont un puissant système de passage de paramètres, la [[curryfication]], le support du [[typage statique]] (mais son utilisation reste optionnelle), l'[[évaluation paresseuse]], le [[filtrage par motif]], l'expression du parallélisme dans le code source pour utiliser au mieux les [[multiprocesseur]]s ou les [[microprocesseur multi cœur|processeurs multi cœur]], et, optionnellement, l'[[inférence de types]]. Le but est, selon Larry Wall, de rendre les choses simples plus simples et les choses compliquées plus facilement réalisables. === Une spécification === En Perl 5, la référence est la mise en œuvre unique du langage. Si la documentation et la mise en œuvre divergent, sauf [[bogue (informatique)|bogue]] avéré, c'est la documentation qui doit être amendée. Ce système n'est plus possible car il semble que Perl 6 aura au moins deux mises en œuvre. De plus, pour une mise en œuvre donnée, il pourra y avoir des générateurs de code réalisés par des tierces parties. Perl 6 est spécifié par des documents appelés synopsis. Ils ont été précédés par des [[apocalypse]]s (au sens de révélation) qui expliquaient et motivaient les premières décisions. Les apocalypses ont maintenant une valeur purement historique. Durant 2006, [[Pugs]], une première mise en œuvre écrite en Haskell était suffisamment avancée pour permettre d'écrire des jeux de tests, de valider, de corriger et d'affiner les spécifications. === Un système typé === Le système statique de typage de Perl 5 comporte peu de types. Lors de la déclaration d'une variable, son [[sigil (informatique)|sigil]] détermine si elle est de type [[scalaire]], [[tableau (structure de données)|tableau]] ou hash ([[métonymie|métonyme]] pour [[table associative]]). Un scalaire peut contenir un [[entier (informatique)|entier]], un [[nombre flottant|flottant]] ou une [[chaîne de caractères]]. Puisque le type du contenant ne détermine que partiellement le type du contenu, on parle de typage semi-dynamique. En Perl 6, les sigils et le [[typage dynamique]] de Perl 5 ont été étendus par l'addition de [[typage statique|types statiques]]. Cela consiste en la déclaration explicite du type du contenant. Par exemple : my int $i = 0; my num $n = 3.141; my str $s = "Hello, world"; Cependant, tout comme en Perl 5, les programmeurs peuvent se passer de typage explicite : my $i = "25" + 10; Le typage statique est une forme de documentation et de tests intégrée au code source. Il améliore la maintenance, spécialement dans les grands projets logiciels. Mais le typage statique alourdit le code de [[langage de script|script]]s courts ou d'[[uniligne]]s. Ce style concis sans déclaration explicite de type autre que par les sigils est une force du Perl lorsque utilisé pour l'écriture de code à usage unique. Perl 6 introduit aussi des sigils secondaires appelés [[twigil]]s. === Liste formelle de paramètres de sous-routines === ==== Carence en Perl 5 ==== Perl 5 définit les sous-routines sans liste formelle de [[paramètre]]s. Les arguments de sous-routines entrant dans une sous-routine devenaient des alias dans les éléments du tableau <tt>@_</tt>. Si <tt>@_</tt> était modifié, les changements étaient reflétés dans les données originales : # Code Perl 5 sub incr { $_[0]++ } my $x = 1; incr($x); # $x est maintenant 2 incr(3); # erreur de [[moteur d'exécution|runtime]] : "Essai de modification d'une valeur en lecture seule" Note: Le système de prototypes, ajout tardif au langage, est un moyen de vérification du nombre de paramètres et une faible vérification de type. ==== Système complexe mais puissant en Perl 6 ==== Perl 6 introduit un vrai formalisme de paramètres dans le langage qui va au delà des [[signature de type|signatures de types]]. <!-- developper --> En Perl 6, une déclaration de sous-routine ressemble à : sub faire_quelquechose(Str $chose, Int $autre) { ... } Comme en Perl 5, les paramètres formels (exemple, les pseudo-variables dans la liste de paramètres) sont aliasés en leurs paramètres effectifs (valeurs d'entrées), mais par défaut, les alias sont marqués <tt>is readonly</tt> (signifiant qu'ils sont en lecture seule et donc constants) non modifiables : sub incr(Num $x) { $x++; # compile-time error } Si un paramètre formel est suivi par <tt>is copy</tt> ou <tt>is rw</tt>, cependant, il ''peut'' être modifié. Dans le cas <tt>is copy</tt>, Perl 6 copie les paramètres actuels plutôt que des les aliaser ; ainsi ils peuvent être modifiés, mais les changements restent locaux à la sous-routine. Dans le cas <tt>is rw</tt> (<tt>rw</tt> signifie lecture-écriture, ''read-write'' en anglais), l'alias n'est pas marqué readonly. Ce changement détecte aussi, lors de la [[Compilateur|compilation]], des erreurs telles que : sub incr(Num $x is rw) { $x++ } incr(3); # erreur au moment de la compilation sub incr_copy(Num $x is copy) { $x++ } incr_copy(3); # Pas de problème De nouvelles fonctionnalités de Perl 6 dans les listes de paramètres rendent le passage de paramètres beaucoup plus puissant qu'en Perl 5 : * <tt>=</tt> après un paramètre permet d'assigner des valeurs par défaut. * <tt>?</tt> après un paramètre indique des arguments optionnels. * <tt>:</tt> avant un paramètre indique un argument nommé (passé comme élément d'hash). * <tt>where</tt> peut fournir une condition que le paramètre doit respecter. Par exemple : sub my_split(Rule $pat? = rx/\s+/, Str $expr? = $_, Int $lim? where $^lim >= 0) { ... } Perl 6 supporte aussi la [[curryfication]]. === Invariance du sigil === En Perl 5, le [[Sigil (informatique)|sigil]] — le caractère non alphanumérique qui précède un nom de variable — pouvait changer selon son contexte d'utilisation (scalaire ou tableau) : # Perl 5 code my <span style="color:red">@</span>array = (0, 1, 2, 3); my $element = <span style="color:red">$</span>array[1]; # $element est égal à 1 En Perl 6, l'abondance des contextes possibles nécessite un mécanisme différent des sigils. Le sigil ne désigne plus le contexte d'accès. Perl 6 propose des opérateurs spécialisés pour ce faire. Le sigil d'une variable est donc invariant. Il est plus pédagogique d'avoir deux mécanismes syntaxiques pour deux fonctions grammaticales différentes (le typage faible de la variable et son contexte d'accès). # Perl 6 code my <span style="color:red">@</span>array = (0, 1, 2, 3); my $element = <span style="color:red">@</span>array[1]; # $element est égal à 1 === Orientation objet === Perl 5 supportait l'[[orientation objet]] via un mécanisme propre à Perl et nommé bénédiction. N'importe quelle [[référence (informatique)|référence]] pouvait être bénie comme étant un objet d'une [[classe (informatique)|classe]] particulière, comme : # Perl 5 code my $object = bless $reference, 'Class'; Un objet béni pouvait alors avoir des [[méthode (informatique)|méthode]]s invoquées en utilisant la « syntaxe flèche » : # Perl 5 code $objet->méthode(); L'invocation identifie la [[sous-routine]] appropriée de nom <code>méthode</code>, et l'appelle avec <code>$objet</code> comme premier argument. Bien que très puissant — virtuellement n'importe quel autre modèle objet d'un autre langage pouvait être simulé en utilisant cette simple fonctionnalité — il rendait le cas le plus commun d'orientation objet, comme une structure [[langage C|C]] associée à du code, inutilement difficile. De plus, Perl ne pouvant faire d'hypothèse sur le modèle objet utilisé, l'invocation de méthode ne pouvait pas être très bien optimisée. Dans l'esprit de rendre les choses simples plus simples, et les choses compliquées faciles, Perl 6 garde le principe de bénédiction pour créer une instance pour les programmeurs qui désirent des fonctionnalités communes. Cela fournit un modèle objet plus robuste pour les cas communs. Par exemple, une classe pour encapsuler un [[point (géométrie)|point]] [[coordonnées cartésiennes|cartésien]] peut être écrite comme : class Point is rw { has $.x; has $.y; } et utilisée : my Point $point .= new; $point.x = 1.2; $point.y = -3.7; Le point remplace la flèche (propre à Perl 5) comme opérateur d'accès au membre d'une instance. C'est la syntaxe propre à de nombreux langages dont [[C++]], [[Java (langage)|Java]], [[Python (langage)|Python]], et [[Ruby]]. Notez que les méthodes « <code>x</code> » et « <code>y</code> » ne sont pas déclarées explicitement. Elles sont appelées des auto-accesseurs. Le modificateur « is rw » dans la définition de la classe permet à tous ses attributs publics d'être écrits par défaut, en utilisant les auto-accesseurs.[http://dev.perl.org/perl6/doc/design/syn/S12.html] Les données membres d'une instance sont appelés « attributs » Elles peuvent être déclarées ainsi : has $.a; # mode d'accès par défaut (généralement en lecture seule) has $.b is rw; # accès en lecture et en écriture has $!c; # membre privé; pas d'accesseur public has $d; # comme $!d === Expressions rationnelles === Les expressions rationnelles (en anglais, ''regex'', pour ''regular expression'') de Perl ont connu tellement de succès qu'elles ont été mises en œuvre par une bibliothèque appelée [[PCRE]] (Perl Compatible Regular Expressions). Via PCRE, les expressions rationnelles ont été incluses sans amélioration dans beaucoup d'autres langages. Pourtant, comme le fait remarquer Larry Wall, ce sont les expressions rationnelles qui ont contribué à donner à Perl une réputation de langage peu lisible. Elle sont trop compactes et trop malignes, les mêmes caractères sont utilisés pour des usages divers. Il y a peu de support pour les captures nommées, peu de support pour les grammaires, et une intégration pauvre avec les langages réels. [http://dev.perl.org/perl6/doc/design/apo/A05.html] Perl 6 fournit un sur-ensemble des fonctionnalités de Perl 5 concernant les expressions rationnelles. Le mécanisme des regex fournit une puissance comparable aux analyseurs syntaxiques. Ces regex agissent comme des [[fermeture]]s par rapport à leur champ lexical. Les regex sont introduites avec un des mots-clefs <code>rule</code>, <code>regex</code>, <code>token</code>. La définition d'une regex est similaire à une définition de sous-routine et peut admettre des paramètres. Le choix du mot-clef permet de contrôler si les espaces sont significatifs ou non dans la regex, et de spécifier s'il peut y avoir retour sur trace ou non. Comme en Perl 5, on peut aussi définir des regex anonymes ou les utiliser directement dans les opérateurs <code>m</code> (matching) ou <code>s</code> (chercher et remplacer). Seules six fonctionnalités n'ont pas été changées depuis les regex du Perl 5 : * Littéraux : les caractères de mots tels que « A » et souligné seront reconnus littéralement. * Capture : <code>(...)</code> * Alternatives : <code>|</code> * Séquences d'échappement par barre oblique inverse (backslash) : <code>\</code> * Les quantificateurs de répétition : <code>*</code>, <code>+</code>, et <code>?</code> * Suffixe de reconnaissance minimale : <code>*?</code>, <code>+?</code>, <code>??</code> Quelques-uns des ajouts les plus efficaces sont : * La possibilité de référencer des règles en utilisant <code><rulename></code> pour construire des grammaires entières. * Des opérateurs de commission permettent au programmeur de contrôler les [[retour sur trace|retours sur trace]] pendant la reconnaissance. Les changements suivants ont grandement augmenté la lisibilité des regexes : * Simplification des groupes non-capturant : <code>[...]</code> qui sont les mêmes que ceux du Perl 5's : <code>(?:...)</code> * des codes assertions simplifiés : <code><?{...}></code> * Le <code>/x</code> de Perl 5 est maintenant le défaut. Exemples : rx { a [ b | c ] ( d | e ) f : g } rx { ?( ab* ) <{ $1.size % 2 == 0 }> } La dernière ligne est identique à : rx { ( ab[bb]* ) } === Simplification syntaxique === Les parenthèses des prédicats de [[Structure de contrôle|contrôle de flot]] en Perl 5 sont maintenant optionnelle : if is_true() { for @array { ... } } Les trois points ci-dessus (<code>...</code>) sont syntaxiquement valides en Perl 6 et constituent l'opérateur « yadda-yadda ». « <code>...</code> » peut être utilisé comme une [[marque substitutive]] pour du code qui doit être inséré par la suite. Si un programme essaye d' ''exécuter'' « <code>...</code> », cependant, une [[Système de gestion d'exceptions|exception]] est levée. Cet opérateur est utile pour les [[méthode (informatique)|méthodes abstraites]], ou bien pour marquer les places où le programmeur essaye d'insérer du code plus tard. === Comparaisons chaînées === Les nouveaux programmeurs attendent souvent que les [[Relation d'ordre|comparaison]]s chaînées comme le suivant fonctionnent : if 1 <= $dé1 == $dé2 <= 6 { say "Doubles!" } En Perl 6, ce code fonctionne maintenant naturellement, dans l'esprit du [[DWIM]] (''Do What I Mean''), et s'exécute comme : if 1 <= $dé1 and $dé1 == $dé2 and $dé2 <= 6 { say "Doubles!" } === Évaluation paresseuse === Perl 6 propose l'[[évaluation paresseuse]] de listes qui est une fonctionnalité de certains langages de [[programmation fonctionnelle]] tels que [[Haskell]]. L'évaluation paresseuse simplifie des tâches communes en Perl6 comme les opérations d'entrées/sorties, la transformation de listes et le passage d'arguments à une routine : my int @integers = 0..Inf; # entiers de 0 à l'infini Le code ci-dessus ne [[crash (informatique)|crashera]] pas en essayant d'assigner une liste de taille infinie à la table <code>@integers</code>. À cause de cette fonctionnalité, l'[[idiome]] Perl pour lire la liste d'arguments sur l'[[entrée standard]] : # Perl 5 code while (<>) { print; } est remplacé par : for =<> { print; } L'opérateur préfix <code>=</code> transforme un [[descripteur de fichier]] ou un nom de fichier en un [[itérateur]]. L'évaluation paresseuse de Perl 6 du <code>for</code> signifie que la boucle Perl 6 <code>for</code> ci-dessus ne doit pas être sujette à aucune conversion spéciale pour fonctionner comme attendu. === Jonctions === Perl 6 introduit le concept de ''jonctions''. Nous choisissons ce terme pour le distinguer des [[jointure]]s, concept propre aux [[base de données relationnelle | bases de données relationnelles]]. Les jonctions sont des valeurs scalaires composites. Les jonctions ont été initialement appelées superpositions, par analogie au concept de [[physique quantique]] de [[superposition]]s quantiques — des courbes qui peuvent simultanément occuper plusieurs états jusqu'à ce que leur observation les ''effondre''. Un module Perl 5 réalisé en l'an [[2000]] par [[Damian Conway]] appelé <code>[http://search.cpan.org/dist/Quantum-Superpositions/lib/Quantum/Superpositions.pm Quantum::Superpositions]</code> fournissait une preuve de concept initiale. D'abord une curiosité programmatique, les jonctions sont un concept important de Perl 6. Dans leur forme la plus simple, les jonctions sont créées par combinaison d'un ensemble de valeurs avec l'[[opérateur]] de jonction : my $even_digit = 0|2|4|6|8; # any(0, 2, 4, 6, 8) my $odd_digits = 1&3&5&7&9; # all(1, 3, 5, 7, 9) my $not_zero = none(0); Ces valeurs peuvent être utilisées arithmétiquement : 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) ou dans des comparaisons : if $grade eq any('A'..'D') { say "pass" } ou même pour l'accès à un tableau : if %person{any('first_name','nickname')} eq "Joe" { say "What do you know, Joe?" } Les jonctions peuvent aussi être utilisées pour étendre le système de types : class RGB_Color is Tuple[int,3] & Color { ... } sub get_tint (RGB_Color|CMYK_Color $color, num $opacity where 0 <= $^opacity <= 1) { ... } sub store_record (Record&Storable $rec) { ... } Les jonctions ne sont pas ordonnées ; <code>1|2|3</code> et <code>3|2|1</code> représentent les mêmes valeurs. Cette absence d'ordre signifie que le compilateur Perl 6 peut choisir d'évaluer les expressions jonctives ''en parallèle''. En fait, plusieurs dans la communauté Perl 6 croient que les jonctions peuvent surpasser l'explicite [[multithreading]] comme manière ordinaire d'accomplir le [[parallélisme (informatique)|parallélisme]] en Perl 6. Par exemple, le code for all(@array) { ...} pourrait indiquer au compilateur que la boucle <code>for</code> doit être exécutée en parallèle plutôt qu'en série. === Macros === Dans les langages de bas niveau, le concept de [[macro]]s a été synonyme de substitutions textuelles du code source à cause de la large utilisation d'un [[préprocesseur]] ignorant la syntaxe du langage. Le [[langage C]] utilise la construction <code>#define</code>. Perl 5 utilise des systèmes de [[filtre (informatique)|filtre]]s sources à cet effet. Ils sont notoirement peu fiables, car leur empilement a des effet aléatoires. En effet chaque filtre suppose que le code qu'il filtre est du code Perl 5 alors qu'il reçoit du code modifié par ces prédécesseurs. <br>[[Lisp]] est privilégié, car il propose un système de macros qui manipulent directement l'arbre syntaxique correspondant au source du programme. C'est facile car sa [[syntaxe concrète]] est identique à sa syntaxe abstraite. Perl 6 proposera les deux type de macro: substitutions textuelles et manipulation de l'[[Abstract syntax tree|AST]]. <br>Une définition de macro Perl 6 ressemblera à une définition de sous-routine ou méthode, et peut travailler sur des chaînes non analysées, un arbre de syntaxe abstrait [[Abstract syntax tree|AST]] représentant du code pré-analysé, ou encore une combinaison des deux. Une définition de macro pourrait ressembler à : macro hello($what) { q:code { say "Hello { {{{$what}}} }" }; } Dans cet exemple particulier, la macro n'est pas plus complexe qu'une substitution textuelle en C, mais parce que l'analyse du paramètre de la macro se produit avant que la macro n'opère sur le code appelé, les messages de diagnostic seront beaucoup plus informatifs. Cependant, parce que le corps de la macro est compilé à chaque lancement du programme, diverses techniques d' [[optimisation_de_code|optimisation]] peuvent être employées. == Hello world == En Perl 6 comme en Perl 5, on peut écrire print "Hello world\n"; En Perl 6, on préfèrera écrire le [[hello world]] ainsi : say "Hello world"; <code>say</code> est semblable au <code>say</code> de [[Restructured Extended Executor|REXX]], au <code>writeln</code> de [[Pascal (langage)|Pascal]] et au <code>puts</code> de [[Ruby]] et [[C (langage)|C]]. == JAPH == Comme en Perl 5, les [[JAPH]]s (programmes qui impriment "Just another Perl hacker,") sont de bons moyens d'expérimenter avec Perl 6. Ici un exemple de [[curryfication]] : sub japh (Str $lang) { say "just another $lang hacker"; } my &perl6Japh := &japh.assuming("Perl6"); perl6Japh(); == Voir aussi == * [[Pugs]], la mise en œuvre en Haskell. * [[Parrot (machine virtuelle)|Parrot]], la mise en œuvre en C. * [[Perl (langage)|Perl]], Perl avant Perl 6. * [[The Perl Foundation]], la fondation en charge de la promotion et du développement de Perl. == Liens externes == * {{en}} [http://dev.perl.org/perl6/ site officiel]. * {{en}} [http://feather.perl6.nl/syn/ site plus pédagogique] avec plus de liens sur les documentations. * {{en}} [http://planetsix.perl.org/ agrégateur de blogs sur Perl6]. * {{en}} [http://www.programmersheaven.com/2/Perl6-FAQ FAQ sur Perl 6]. * {{en}} [http://rakudo.org/perl6/ Wiki dédié à Perl 6]. * {{en}} [http://perlcabal.org/syn/Differences.html Perl6::Perl5::Differences] * {{en}} [http://planetsix.perl.org/ Planet Perl 6] {{Portail|informatique|logiciels libres}} [[Catégorie:Perl]] [[Catégorie:Logiciel libre]] [[Catégorie:Langage de programmation]] [[Catégorie:Langage impératif]] [[Catégorie:Langage fonctionnel]] [[Catégorie:Langage orienté objet]] [[Catégorie:Langage de script]] [[cs:Perl 6]] [[de:Perl#Perl_6]] [[en:Perl 6]] [[es:Perl 6]] [[fi:Perl 6]] [[sv:Perl 6]] [[zh:Perl 6]]</text> </revision> </page>