De Perl 5 à Perl 6 - Annexe 2

Les paires et énumérations sont toutes deux des paires de clef-valeur.

Le type Pair représente un type variable (modifiable) de paire alors que le type Enum représente un type immuable (constante) de paire.

1-4-1-1. Les paires▲

my $x = 'clef' => 'valeur';   # mot-clef Pair non requis
my $y = :clef<valeur>;        # idem, crée la paire 'clef' => 'valeur'

# Raccourci créant une paire à partir d'une variable et de sa valeur :
my $le_nombre = 42;
my $z = :$le_nombre;          # crée la paire $z : le_nombre => 42

# Autres notations abrégées:
my $bool_vrai =:vrai;         # crée la paire vrai => True
my $bool_faux =:!faux;        # crée la paire faux => False

sub ttc(Real :$prix-unitaire, Int :$quantité, Rat :$tva) {
    return $prix-unitaire * $quantité * (1 + $tva);
}
say "prix = ", ttc(prix-unitaire => 7.00, quantité => 5, tva => 0.20);
                                         # affiche: prix = 42

say "Vrai" if "bin".path ~~ :e;  #  -> Vrai (le répertoire bin existe)
# fonctionne aussi directement avec la variable par défaut $_ :
given "bin".path {
    say "Vrai" if :e;            # -> Vrai
}

1-4-1-2. Les énumérations▲

my enum mois (jan => "01",  fév => "02",  mar => "03", 
              avr => "04",  mai => "05",  jun => "06", 
              jui => "07",  aoû => "08",  sep => "09", 
              oct => "10",  nov => "11",  déc => "12");
say mois.enums;   # imprime aoû => 08, avr => 04, déc => 12, ...

for mois.enums -> $x { say $x.kv}     # ou: say .kv for mois.enums;
avr 04
jan 01
nov 11
jui 07
oct 10
sep 09
fév 02
mar 03
jun 06
aoû 08
déc 12
mai 05

enum E <a b c>;

package E {
        constant a = 0;
        constant b = 1;
        constant c = 2;
    }

1-4-1-3. Une énumération booléenne▲

my enum ouinon <non oui>; # les constantes oui et non prennent vie
say ouinon.enums;         # imprime:  "non" => 0, "oui" => 1
say non.pair;                         # imprime "non" => 0
say oui.pair;                         # imprime "oui" => 1
say "Oui vraiment" if oui;            # imprime Oui vraiment
say "Non" if non;                     # n'imprime rien
say "Non, pas du tout" unless non;    # imprime Non, pas du tout
say oui.kv;                           # imprime oui 1 -- kv = key value

our enum Bool does Boolean <False True>;

say "Oui vraiment" if True;           # imprime Oui vraiment
say "Non, pas du tout" unless False;  # imprime Non, pas du tout

Les jonctions sont des valeurs composites superposant une ou plusieurs valeurs non ordonnées (elles ont été initialement été appelées superpositions, ce mot peut encore être trouvé dans des documents un peu anciens). Les opérations sur les jonctions s'exécutent séparément sur tous les éléments de la jonction (peut-être même en parallèle dans des threads différents si le compilateur et la machine virtuelle le supportent) et une nouvelle jonction du même type est assemblée à partir des résultats partiels.

1-4-2-1. Les différents types de jonctions▲

my $x = 3|4|6;            # $x est une jonction de type any. 
                          # Équivalent à $x = any(3, 4, 6)
say "Vrai" if $x == 4;    # -> Vrai (4 est l'une des valeurs possibles)
my $y = any(4, 7, 11);    # Peut aussi s'écrire $y = 4|7|11
say "Vrai" if $x == $y;   # -> Vrai : 4 est commun aux deux jonctions

1-4-2-2. Quelques utilisations typiques des jonctions▲

say "$_ est un nombre de Fibonacci" 
     for grep { $_ == any(<1 2 3 5 8 13>)}, 7..20; 
     # Affiche : "... est un nombre de Fibonacci" pour 8 et 13

say "$_ est un nombre de Fibonacci" 
     for grep { $_ == 1 or $_ == 2 or $_ == 3 or $_ == 5 
     or $_ == 8 or $_ == 13} 1..20;

say "Chiffres impairs" if  1 & 3 & 5 & 8 %2;  # Faux, n'affiche rien
say "Chiffres impairs" if  1 & 3 & 5 & 7 %2;  # -> Chiffres impairs

my @tableau = <1 3 5 7 >;
say "Trouvé 7" if any(@tableau) == 7;    # -> Trouvé 7
say "Trouvé 8" if any(@tableau) == 8;    # -> N'affiche rien

say ((2|3|4)+7)       # équivalent à 9|10|11 ou any(9, 10, 11)

1-4-2-3. Précautions avec les opérateurs négatifs▲

my @tableau = <a b c d e>;
say "Présent" if 'd' eq any(@tableau); # -> Présent, pas de difficulté
say "Absent"  if 'd' ne any(@tableau); # -> Comment interpréter ?

my @tableau = <a b c d e>;
say "Absent"  if 'd' ne any @tableau;          # n'affiche rien
# équivalent à :
say "Absent"  if not ('d' eq any @tableau);    # n'affiche rien
# ou à:
say "Absent"  unless 'd' eq any @tableau;      # n'affiche rien

say "Absent"  if 'd' eq none @tableau;         # n'affiche rien
say "Absent"  if 'g' eq none @tableau;         # -> Absent

Les ensembles, sacs et mélanges sont des collections non ordonnées d'objets uniques et pondérés. Le mot « collection » sera utilisé ici informellement pour les désigner collectivement, sans que ce terme ait un sens officiellement défini en Perl 6.

On a parfois besoin de rassembler des objets dans un contenant sans que l'ordre ait de l'importance. Perl 6 fournit à cette fin six types de collections non ordonnées : Set et Sethash (ensembles), Bag et BagHash (sacs), Mix et MixHash (assortiments). Comme l'ordre est sans importance, ces collections permettent des recherches plus rapides que dans des listes ordonnées, à la manière des tables de hachage.

Si l'on désire une liste d'éléments sans doublons, on peut utiliser les types Set (ensemble immuable, une sorte de constante) ou SetHash (ensemble mutable ou variable). Pour obtenir une liste sans doublons, mais conservant l'ordre de la liste, consulter la routine (nous utilisons le mot routine pour décrire une subroutine admettant à la fois une syntaxe de fonction et une syntaxe de méthode) unique du type List.

Si l'on désire enregistrer le nombre de fois où chaque élément est présent, on peut utiliser un sac (Bag ou un BagHash). Dans ces sacs, chaque élément est associé à un poids (un décompte sous la forme d'un entier non signé). Les types Mix et MixHash sont semblables, sauf que leur pondération peut être fractionnaire.

Les types Set, Bag et Mix sont immuables (ce sont des constantes). Il faut utiliser leurs variantes mutables (variables), SetHash, BagHash, et MixHash, si l'on désire pouvoir ajouter ou retirer des éléments après la construction de la collection.

Ces six types de collections possèdent la même sémantique et partagent dans une large mesure les mêmes opérateurs spécifiques.

D'une part, des objets identiques réfèrent au même élément, dont l'identité est déterminée en employant la méthode WHICH (de la même manière que l'opérateur === vérifie l'identité). Pour des valeurs de type Str, cela signifie avoir la même valeur. Pour des références vers par exemple des tableaux, cela signifie référer à la même instance d'objet.

D'autre part, ils proposent tous une interface de genre table hachage dans laquelle les éléments de la collection (qui peuvent être des objets de type quelconque) sont les « clefs » et les pondérations associées les « valeurs » :

Ces types de genre collection offrent toute une série d'opérations ensemblistes communes, comme les unions, intersections, différences symétriques, etc., ainsi que les opérateurs booléens d'appartenance, d'inclusion, etc.

Ces opérateurs peuvent être écrits avec le caractère UTF-8 représentant le symbole mathématique correspondant (comme ∈ ou ∪) ou avec une version ASCII correspondante : (elem) ou (|), les parenthèses font partie intégrante de l'opérateur.

La plupart du temps, il n'est pas nécessaire d'utiliser explicitement des objets de type collection pour utiliser ces opérateurs ensemblistes, qui fonctionneront sur tout objet dont les arguments sont de type Any (par exemple, les listes, tableaux, etc.), la coercition dans le type désiré se fera au moment voulu.

my @tableau = <a b c d e>;      # un simple tableau, pas un Set
say 'c appartient à @tableau' if 'c' ∈ @tableau; # -> Vrai
say "Présent" if 'c' (elem) @tableau;            # idem: -> Présent

1-4-3-1. Opérateurs renvoyant une valeur booléenne▲

1-4-3-2. Opérateurs renvoyant un ensemble ou un sac▲

Le tutoriel La programmation fonctionnelle en Perl - Partie 1 : les opérateurs de liste montre comment il est possible d'enchaîner plusieurs opérateurs de listes pour former une sorte de pipeline de données, dans lequel les données en entrée sont manipulées par un premier opérateur de liste qui fournit les données modifiées qu'il produit en entrée à un second opérateur, lequel effectue une nouvelle transformation des données pour les fournir éventuellement à un troisième opérateur de liste, et ainsi de suite le cas échéant. Ceci met en place un modèle de programmation par flux de données (dataflow programming) ou pipeline de données. Cette approche présente l'avantage de diviser un problème relativement complexe en une série de tâches plus simples.

L'exemple classique, voire canonique, de ce genre de processus en Perl 5 est la transformation de Schwartz, qui enchaîne un map, un sort et un map pour trier des données : le premier map enrichit les données avec le critère de tri, le sort effectue le tri, et le dernier map remet les données au format d'origine. Le lecteur intéressé est invité à consulter le lien ci-dessus, la mise en place d'une transformation de Schwartz étant moins d'actualité en Perl 6 dans la mesure où elle est automatiquement mise en œuvre par le langage quand la fonction de comparaison utilisée par le sort ne prend qu'un seul paramètre (voir un exemple à la fin de ce chapitre).

Quelques-uns des exemples d'utilisation des opérateurs de listes donnés dans le tableau ci-dessus utilisent de façon très modérée cette technique. Ainsi, les exemples :

# fonction combinations
print map {" $_ "}, .join('|') for <a b c>.combinations(2); 
                        # -> a|b  a|c  b|c >
# fonction rotor
say ('a'..'g').rotor(3).join('|');           # a b c|d e f

enchaînent ainsi plusieurs opérateurs de listes, dans ces cas dans le seul but de formater le résultat de la fonction étudiée.

Voici, transposé en Perl 6, un exemple inspiré du tutoriel sur la programmation fonctionnelle en Perl 5 mentionné ci-dessus (Trier un tableau selon l'ordre de tri d'un autre tableau). On a en entrée un tableau d'employés et un tableau de salaires :

my @noms = <marie nicolas isabelle yves>;
my @salaires = <1500 950 1700 2000>;

Le premier nom reçoit le premier salaire (Marie reçoit 1500), et ainsi de suite. On désire trier les employés selon le montant de leur salaire. La structure de données avec deux tableaux n'est pas vraiment appropriée. Il est préférable de commencer par construire une table de hachage, par exemple avec l'opérateur zip, puis de trier ce hachage selon le salaire :

my %noms-sal = @noms Z  @salaires;
# -> isabelle => 1700, marie => 1500, nicolas => 950, yves => 2000
.say for sort { %noms-sal{$^a} <=> %noms-sal{$^b} }, keys  %noms-sal;
# -> nicolas marie isabelle yves

my $block = { say "$^c $^a $^b" };
$block(1, 2, 3);          # imprime :  3 1 2

Il est même possible de se passer du hachage intermédiaire, de faire les deux opérations en une seule ligne enchaînant les instructions individuelles et d'afficher les paires employé-salaire :

.say for sort {$^a.value <=> $^b.value}, %(@noms Z  @salaires);
# nicolas => 950
# marie => 1500
# isabelle => 1700
# yves => 2000

Ou d'utiliser la transformation de Schwartz implicite, ce qui implique de reformater les salaires sur le même nombre de chiffres pour que la comparaison lexicographique soit équivalente à la comparaison numérique :

.say  for sort {sprintf "%04d", $_.value}, %(@noms Z  @salaires);
     # même résultat

Les nouvelles fonctions de liste de Perl 6 étendent considérablement ce que l'on peut faire avec ce modèle de programmation.

Pour quiconque n'a pas un peu l'habitude de la programmation fonctionnelle, la fonction reduce décrite au § 4.1 ci-dessus ne paie peut-être pas vraiment de mine. Elle applique une fonction aux deux premiers éléments d'une liste pour obtenir un premier résultat, puis la même fonction au résultat et au troisième élément de la liste, et ainsi de suite. Que peut-on faire avec cela ? L'exemple (nécessairement un peu simpliste) donné ci-dessus donne une première idée :

my $somme_1_10 = (1..10).reduce: * + *; # -> 55

Pas de quoi s'extasier, cependant. On peut généraliser ou abstraire l'idée en en faisant une fonction somme réutilisable :

sub somme (*@a) { @a.reduce: * + *}
say somme 1..10;          # -> 55
say somme 1..20;          # -> 210
my @tableau = <5 7 6 8 4>
say somme @tableau;       # -> 30
say somme <1 7 6 8>;      # -> 22

Bien sûr, on peut créer une fonction produit sur le même modèle. Mais reduce permet bien d'autres choses, comme déterminer l'élément le plus grand d'un tableau :

say "max = ", <1 5 7 4 3 14 12 5>.reduce: {$^a > $^b ?? $^a !! $^b};
                          # -> max = 14

On pourra dès lors créer des fonctions max et min :

sub max (*@a) {@a.reduce: {$^a > $^b ?? $^a !! $^b}}
say max <2 4 8 6 9>;      # -> 9
say max 4, 6, 8, 17, 5;   # -> 17
sub min (*@a) {@a.reduce: {$^a < $^b ?? $^a !! $^b}}
say min <2 4 8 6 9>;      # -> 2

Ou, si l'on préfère une notation syntaxique fonctionnelle :

sub max (*@a) { reduce {$^a > $^b ?? $^a !! $^b}, @a}
sub min (*@a) { reduce {$^a < $^b ?? $^a !! $^b}, @a}

On voit dès lors qu'il est facile d'enrichir le langage en créant en quelques lignes de code toute une bibliothèque de fonctions de listes :

sub somme    (*@a) {reduce * + *, @a }
sub produit  (*@a) {reduce * * *, @a }
sub max-num  (*@a) {reduce {$^a > $^b ?? $^a !! $^b}, @a}
sub min-num  (*@a) {reduce {$^a < $^b ?? $^a !! $^b}, @a}
sub avg      (*@a) {@a.elems ?? (somme @a) / @a.elems !! Nil} # moyenne
sub variance (*@a) {my $moy = avg @a; avg (map {($_ - $moy)**2}, @a )}
sub std-dev  (*@a) {sqrt variance @a };   # écart-type
sub max-str  (*@a) {reduce {$^a gt $^b ?? $^a !! $^b}, @a}
sub min-str  (*@a) {reduce {$^a gt $^b ?? $^b !! $^a}, @a}
sub longest  (*@a) {reduce {length $^a > length $^b ?? $^a !! $^b}, @a}
sub shortest (*@a) {reduce {length $^b > length $^a ?? $^a !! $^b}, @a}
sub concat   (*@a) {reduce * ~ *, @a}
# etc.

Les métaopérateurs permettent d'aller encore plus loin et de le faire souvent plus simplement.

Le métaopérateur de réduction […] peut travailler sur n'importe quel opérateur infixé associatif et le transformer en opérateur de liste. Tout se passe comme si l'opérateur en question était placé entre chaque élément de la liste, si bien que [op] $i1, $i2, @reste renvoie le même résultat que si l'on avait $i1 op $i2 op @reste[0] op @reste[1] ....

Ce métaopérateur assure à peu près le même rôle que la fonction reduce décrite ci-dessus, mais avec des fonctionnalités supplémentaires et la possibilité de travailler directement sur un opérateur interne.

C'est une construction extrêmement puissante qui promeut l'opérateur + au rang d'une fonction somme, l'opérateur ~ à celui d'un join (avec des séparateurs vides), et ainsi de suite.

Le calcul d'une somme décrit au § 4.1.2 ci-dessus peut être réécrit comme suit :

my $somme_1_10 = [+] 1..10; # -> 55. NB: espace nécessaire après [+]

On pourrait de même réécrire la fonction somme :

sub somme (*@a) { [+] @a }
say somme 1..10;            # -> 55

mais il n'est pas certain qu'il soit encore utile d'écrire une fonction dédiée, tant l'utilisation directe du métaopérateur de réduction est aisée.

Il est de même possible de créer une fonction factorielle comme suit :

sub fact(Int $x){
    [*] 1..$x; 
}
my $c = fact(10);     # -> 3628800

Si vous avez au moins un peu pratiqué la programmation fonctionnelle, vous avez sans doute rencontré les fonctions reduce, fold, foldl ou foldr (par exemple en Lisp ou en Haskell). Contrairement à ce qui se passe dans ces langages, et contrairement à la fonction reduce de Perl 6 vue précédemment, le métaopérateur […] respecte l'associativité de l'opérateur concerné, en sorte que [/] 1, 2, 3 est interprété comme (1 / 2) / 3 et [-] 4, 3, 2 comme (4 - 3) - 2 (opérateurs associatifs à gauche) , alors que [**] 1, 2, 3 est correctement interprété comme 1 ** (2**3) (associatif à droite). Le chapitre Précédence des opérateurs du tutoriel donne un tableau récapitulant notamment l'associativité des différents opérateurs de Perl 6.

Les espaces blancs sont interdits à l'intérieur des crochets : vous pouvez écrire [+], mais pas [ + ]. (Cela contribue à lever les ambiguïtés avec les tableaux.)

Comme les opérateurs de comparaison peuvent être chaînés, vous pouvez aussi écrire des choses du style :

say "true" if [<] 1, 3, 6, 8;      # "true"

if    [==] @nums { say "Tous les nombres de @nums sont identiques" }
elsif [<]  @nums { say "le tableau @nums est dans un ordre ascendant strict" }
elsif [<=] @nums { say "le tableau @nums est dans un ordre ascendant"}

Il existe une forme particulière de cet opérateur qui utilise un antislash comme ceci : [\+]. Elle renvoie les résultats des évaluations partielles intermédiaires. Par exemple, [\+] 1..3 renvoie la liste 1, 1+2, 1+2+3, ce qui donne bien sûr 1, 3, 6.

De même, en utilisant cette forme du métaopérateur de réduction avec l'opérateur de concaténation :

say [\~] 'a' .. 'd'     # -> <a ab abc abcd>

Comme les opérateurs associatifs à droite s'évaluent de droite à gauche, on obtient aussi les résultats partiels dans cet ordre :

say [\**] 1..3;         # -> 3, 2**3, 1**(2**3), soit 3, 8, 1

Il est possible d'enchaîner plusieurs opérateurs de réduction (qui s'exécuteront alors de droite à gauche) :

say [~] [\**] 1..3;     # -> "381"

Ou même :

say [\~] [\**] 1..3;     # -> "3 38 381"

L'opérateur croix (ou cross) X a été décrit au début du tableau des opérateurs de listes du § 4.1. Il renvoie un produit cartésien entre deux ou plusieurs listes, c'est-à-dire une liste de tous les tuples possibles dans lesquels le premier élément est un élément de la première liste, le second élément un élément de la seconde liste, et ainsi de suite :

print "($_) " for <a b> X 1,2 X <x y>;
# -> (a 1 x) (a 1 y) (a 2 x) (a 2 y) (b 1 x) (b 1 y) (b 2 x) (b 2 y)

Cet opérateur X peut aussi agir comme un métaopérateur : s'il est suivi d'un opérateur infixé, alors le deuxième opérateur est appliqué à tous les éléments des tuples et ce sont les résultats de cette opération sur chaque élément qui sont renvoyés. Par exemple, en postfixant la croix de l'opérateur de concaténation dans l'exemple ci-dessus :

# -> a1x a1y a2x a2y b1x b1y b2x b2y
say <a b> X~ 1,2 X~ <x y>;

Un bon vieux problème classique de l'algorithmique est la détermination des nombres de Hamming. Il s'agit des nombres de la forme :

Autrement dit, ce sont les nombres dont tous les diviseurs premiers sont inférieurs ou égaux à 5. Le métaopérateur X, utilisé de deux manières différentes, va permettre de construire aisément une liste de nombres de Hamming.

Combiné à l'opérateur d'exponentiation **, ce métaopérateur permet de générer facilement une liste de puissances de 2 :

say 2 X** 0..10;  # -> 1 2 4 8 16 32 64 128 256 512 1024

On peut générer de la même façon les listes de puissances de 3 et de 5. Et on peut utiliser à nouveau le métaopérateur X, combiné cette fois à l'opérateur de multiplication *, sur ces trois listes pour générer des nombres de Hamming :

my @h = sort ((2 X** 0..10) X* (3 X** 0..10) X* (5 X** 0..10));
# -> 1 2 3 4 5 6 8 9 10 12 15 16 18 20 24 25 27 30 32 36 40 45 48 ...

À remarquer que cette instruction génère environ 1300 nombres de Hamming, mais la liste n'est exhaustive que jusqu'au rang 108 (2025) : le nombre de Hamming suivant (2048 = 2¹¹) est forcément manquant de la liste puisque les puissances de deux utilisées ici s'arrêtent à 2¹⁰. Il n'est pas bien difficile d'ajuster les puissances pour chacun des trois facteurs premiers afin de trouver par exemple le millionième nombre de Hamming (parmi plus de 7 millions d'autres) :

my @h1 = sort ((2 X** 0..300)  X* (3 X** 0..183) X* (5 X** 0..130));
say @h1[999999]; 
# -> 519312780448388736089589843750000000000000000000000000000000000000000000000000000000

mais le traitement prend quelques dizaines de minutes.

Les métaopérateurs de réduction prennent en entrée une liste et renvoient un scalaire ; les hyperopérateurs appliquent l'opération spécifiée à chaque élément de la liste et renvoient la liste transformée (un peu comme un map). On construit les hyperopérateurs avec les guillemets français « ». Si votre éditeur de texte ou votre clavier ne permet pas d'utiliser les guillemets français, il est possible d'utiliser les symboles ASCII chevrons << et >> à la place.

my @a = 1..5;
my @b = 6..10;
my @c = 5 «*» @b;
say @c;              # imprime 30 35 40 45 50 (5*6, 5*7, 5*8 ...)
my @d = @a »*« @b;
say @d;              # imprime 6 14 24 36 50 (1*6, 2*7, 3*8, ...)

On peut également utiliser les hyperopérateurs avec des opérateurs unaires :

my @a = 2, 4, 6;
say -« @a;      # imprime  -2 -4 -6

Les hyperopérateurs unaires renvoient toujours une liste de la même taille que la liste en entrée.

Les hyperopérateurs infixés ont un comportement différent selon la taille de leurs opérandes :

@a >>+<< @b;   # @a et @b doivent avoir la même taille
@a <<+<< @b;   # @a peut-être plus petit
@a >>+>> @b;   # @b peut-être plus petit
@a <<+>> @b;   # L'un ou l'autre peut être plus petit, Perl fera ce que vous voulez dire (DWIM)

L'exemple ci-dessus illustre aussi au passage l'utilisation des chevrons ASCII en lieu et place des guillemets français s'ils ne sont pas facilement disponibles dans l'éditeur utilisé.

Les hyperopérateurs fonctionnent aussi avec les opérateurs d'affectation :

@x »+=« @y;    # Même chose que @x = @x »+« @y

Dans une expression comme $d = $a + $b * $c, la multiplication entre $b et $c est effectuée avant la somme de ce produit avec $a. L'opérateur infix:<*> a une précédence ou priorité d'exécution supérieure à celle de l'opérateur infix:<+>, et c'est pourquoi l'expression est évaluée comme si elle était écrite $a + ($b * $c), conformément aux conventions mathématiques usuelles (voir dans le tutoriel le tableau des précédences des opérateurs internes de Perl 6).

Lorsque l'on définit un nouvel opérateur, il est généralement important de définir sa précédence, ce qui se fait par rapport aux opérateurs existants :

multi sub infix:<toto> is   equiv(&infix:<+>) { ... }

multi sub infix:<titi> is tighter(&infix:<+>) { ... }

multi sub infix:<tata> is  looser(&infix:<+>) { ... }

Par exemple, on peut écrire ce qui suit :

multi sub infix:<double_somme> (Int $x, Int $y) is equiv(&infix:<+>) {
     2 * ($x + $y)
}
say 4 double_somme 5;      # imprime 18

multi sub infix:«3s» (Int $x, Int $y) is equiv(&infix:<*>) {
     3 * ($x + $y)         # triple somme
}
say 9 3s 5;                # imprime 42

L'associativité détermine comment s'évalue la priorité de plus de deux opérateurs ayant la même précédence.

La plupart des opérateurs ne prennent que deux arguments. Mais dans une expression comme $c = 1 / 2 / 4, c'est l'associativité de l'opérateur qui décide dans quel ordre le résultat est évalué. L'opérateur infix</> est associatif à gauche, ce qui veut dire que l'expression est évaluée de la façon suivante : (1 / 2) / 4, ce qui donne 1/8. Si elle était associative à droite, cela donnerait 1 / (2 / 4) = 1/2.

On voit que la différence est cruciale. Pour un opérateur associatif à droite comme infix:<**> (puissance), l'expression 2 ** 2 ** 4 est comprise comme 2 ** (2 ** 4), soit 65 536. Si l'associativité était à gauche, on obtiendrait 256. L'associativité des opérateurs internes de Perl a été donnée le tableau des précédences des opérateurs internes du présent tutoriel.

Perl 6 offre plusieurs associativités : none interdit le chaînage des opérateurs ayant la même précédence (par exemple, 2 <=> 3 <=> 4 est proscrit). Et infix:<,> a une associativité de liste. 1, 2, 3 se traduit en infix:<,>(1; 2; 3). Enfin, il y a l'associativité chaînée : $a < $b < $c se traduit en ($a < $b) && ($b < $c).

Les opérateurs postcirconfixés sont des invocations de méthodes.

class OrderedHash is Hash {
     method postcircumfix:<{ }>(Str $key) {
         ...
     }
}

Si on invoque cette méthode avec un appel du genre $objet{$truc}, $truc sera passé en argument à la méthode et l'invoquant $objet sera accessible via $self.

Les opérateurs circonfixés impliquent généralement une syntaxe différente (par exemple : my @list = <a b c>;), et sont donc implémentés sous la forme de macros :

macro circumfix:«< >»($text) is parsed / <-[>]>+ / {
    return $text.comb(rx/\S+/);
}

Le trait is parsed est suivi d'une regex qui analyse tout ce qui se trouve entre les délimiteurs. S'il n'y a pas de règle de ce type fournie, alors c'est analysé comme du code Perl ordinaire (mais ce n'est généralement pas ce que l'on veut quand on introduit une nouvelle syntaxe). Str.comb recherche les occurrences d'une regex et renvoie une liste des textes reconnus.

Parfois, le type (préfixé, infixé, etc.) d'un nouvel opérateur suffit à lui seul à le distinguer d'un opérateur existant ayant le même nom. Par exemple, l'opérateur! de négation booléenne est préfixé. Il est donc très simple de créer un nouvel opérateur! postfixé pour dénoter la factorielle d'un entier :

sub postfix:<!> (Int $n) {
    [*] 2..$n
}
say 10!; #    -> 3628800   - Attention : pas d'espace entre 10 et !

Voici une version un peu plus prudente vérifiant que le nombre reçu en paramètre est positif, ainsi qu'un exemple de jeu de tests minimal :

sub postfix:<!> (Int $n) {
    fail "Le paramètre n'est pas un entier naturel" if $n < 0;
    [*] 2..$n
}

use Test;
isa-ok (-1)!, Failure, "Factorielle échoue pour -1";
ok 0! == 1, "Factorielle 0";
ok 1! == 1, "Factorielle 1";
ok 5! == 120, "Factorielle d'un entier plus grand";

Quand le type prévu du nouvel opérateur ne suffit pas à le distinguer d'un opérateur existant, la signature peut apporter le comportement attendu. La plupart des opérateurs existants (voire tous) sont des fonctions ou des méthodes de type multi, et il est donc facile d'en faire des versions « sur mesure » pour de nouveaux types. Ajouter une fonction multi est la façon la plus courante de surcharger un opérateur :

class MyStr { ... }
multi sub infix:<~>(MyStr $this, Str $other) { ... }

Ceci signifie qu'il est possible d'écrire des objets qui se comportent exactement comme les objets « spéciaux » tels que Str, Int, etc.

Il est par exemple possible de définir une addition membre à membre entre des paires. Ceci permettrait par exemple de manipuler des nombres complexes. En fait, il existe une classe interne Complex définissant le type complexe (et c'est évidemment elle qu'il faudrait utiliser pour faire des opérations sur les nombres complexes), mais cela va nous permettre de donner un exemple assez complet et parlant de surcharge d'opérateurs arithmétiques.

Voici par exemple comment calculer l'opposé d'un nombre complexe opérateur (- unaire), additionner et multiplier des nombres complexes (définis comme des paires exprimant les formes cartésiennes de nombres complexes) :

#!/usr/bin/perl6
use v6;

multi sub prefix:<-> (Pair $x) is equiv(&prefix:<->) {
    # opposé d'un nombre complexe
    - $x.key => - $x.value;
}

multi sub infix:<+> (Pair $x, Pair $y) is equiv(&infix:<+>) {
    # somme de nombres complexes
    my $key = $x.key + $y.key; 
    my $val = $x.value + $y.value; 
    return $key=>$val
}

multi sub infix:<*> (Pair $x, Pair $y) is equiv(&infix:<*>) {
    # produit de nombres complexes
    my $key = $x.key * $y.key - $x.value * $y.value; 
    my $val = $x.key * $y.value + $x.value * $y.key; 
    return $key=>$val
}

my $a = 4=>3;          # une paire pour le complexe 4 + 3i
say - $a;              # imprime -4 => -3
my $b = 5=>7;
say $a + $b;           # imprime 9 => 10

my $c = 3.5 => 1/3;    # NB: Perl 6 stocke en interne le rationnel
                       # (classe Rat) 1/3, pas 0.333...
my $d = 1/2 => 2/3;    # idem pour 2/3
say $c + $d;           # imprime 4.0 => 1.0;
say $c +(1/2=>4/3);    # imprime 4.0 => <5/3>;

say $a * $b;           # imprime -1 => 43
say $c * $d;           # imprime <55/36> => 2.5
say $c + $a * $b;      # imprime 2.5 => <130/3>; 
                       # bien comme : say $c + ($a * $b);

Le dernier exemple montre que les règles de précédence usuelles en mathématiques sont bien respectées (la multiplication est exécutée avant l'addition).

L'utilisation de la surcharge d'opérateurs existants nécessite quelques précautions : dans l'exemple ci-dessus, s'il existait déjà un opérateur + ou * sur les paires (ou sur un type dont les paires héritent dans la hiérarchie des types), en créer un nouveau générerait une ambiguïté que le compilateur ne pourrait résoudre. On aurait alors un message du type :

Ambiguous call to 'infix <+>'; these signatures all match:
:(Pair $x, Pair $y)
:(Pair $x, Pair $y)
in any at ...

Il faut donc s'assurer que les signatures permettent au compilateur de choisir la bonne multi sub. Le problème ne se pose pas ici, car ces opérateurs ne sont pas définis pour des paires. Dans l'hypothèse où ce serait le cas, le problème se résoudrait simplement si, au lieu d'utiliser directement des paires, on créait un type héritant de Pair et redéfinissant ces opérateurs pour les objets de la nouvelle classe. Cela implique de recourir à la programmation orientée objet.

Les types eux-mêmes sont des objets et il est possible d'obtenir l'objet-type en écrivant simplement son nom :

my obj-type-int = Int;      # -> (Int)

Il est possible de connaître l'objet-type d'un objet quelconque en appelant la méthode WHAT (qui est en fait une macro sous la forme d'une méthode) :

my obj-type-int = 1.WHAT;   # -> (Int)

Il est possible de vérifier si des objets-types (à l'exception de Mu, le type au sommet de la hiérarchie des types dont héritent tous les autres) sont égaux à l'aide de l'opérateur d'identité === :

sub f(Int $x) {
    if $x.WHAT === Int {
        say 'Vous avez passé un Int';
    }
    else {
        say 'Vous avez passé un sous-type de Int';
    }
}

En vérité, dans la majeure partie des cas, la méthode .isa (« est un(e) ») sera suffisante et plus simple d'utilisation :

sub f($x) {
    if $x.isa(Int) {
        ...
    }
    ...
}

La vérification de la compatibilité des sous-types se fait avec l'opérateur de reconnaissance intelligente ~~ (smart match) :

my Int $i = 5;
say "Compatible avec réel" if $i ~~ Real; # Int est sous-type de Real
# -> "Compatible avec réel" (Int hérite des méthodes de Real)

Les attributs sont des variables privées qui existent à l'intérieur des membres d'une classe (et que possèdent tous les objets instanciant ladite classe). Ce sont eux qui stockent l'état d'un objet. En Perl 6, tous les attributs sont privés. On les déclare généralement avec le mot-clef has et en utilisant le twigil «!» :

class Voyage {
    has $!point-de-départ;
    has $!destination;
    has @!voyageurs;
    has $!notes;
}

Il n'existe pas en Perl 6 d'attribut public (ou même protégé), mais il existe une manière de générer automatiquement des accesseurs (méthodes d'accès) : il suffit de remplacer le twigil «!» par le twigil «.» (moyen mnémotechnique : le «.» devrait vous faire penser à un appel de méthode) :

class Voyage {
    has $.point-de-départ;
    has $.destination;
    has @!voyageurs;
    has $.notes;
}

Ceci fournit par défaut des accesseurs en lecture seule. Pour autoriser des modifications de l'attribut, il faut ajouter le trait is rw :

class Voyage {
    has $.point-de-départ;
    has $.destination;
    has @!voyageurs;
    has $.notes is rw;
}

Désormais, une fois un objet Voyage créé, ses attributs .point-de-départ, .destination et .notes seront accessibles depuis l'extérieur de la classe via les accesseurs, mais, dans le code ci-dessus, seul l'attribut .notes sera modifiable. L'attribut !voyageurs reste privé et inaccessible depuis l'extérieur de la classe.

Comme les classes héritent d'un constructeur par défaut de Mu et comme nous avons demandé que des accesseurs soient générés pour nous, notre classe est déjà presque fonctionnelle :

# Création d'une nouvelle instance de la classe
my $vacances = Voyage.new(
    point-de-départ  => 'Suède',
    destination      => 'Suisse',
    notes            => 'Équipement type camping!'
);

# Utilisation d'un accesseur : 
say $vacances.point-de-départ;    # -> Suède

# Utilisation d'un accesseur de type rw pour modifier la valeur:
$vacances.notes = 'Équipement type camping plus lunettes de soleil';

À noter que le constructeur par défaut n'alimentera que les attributs qui ont un accesseur, mais il peut initialiser des attributs en lecture seule.

On déclare une méthode à l'aide du mot-clef method à l'intérieur du corps d'une classe :

class Voyage {
    has $.départ;
    has $.destination;
    has @!voyageurs;
    has $.notes is rw;

    method ajoute_voyageur($nom) {
        if $nom ne any(@!voyageurs) {
            push @!voyageurs, $nom;
        }
        else {
            warn "$nom est déjà du voyage!";
        }
    }
    method décrire() {
        join " ", "De", $!départ, "à", $!destination,
                  "- Voyageurs:", @!voyageurs;
    }
}

La classe peut être appelée comme suit :

my $week-end-amoureux = Voyage.new(départ      => "Paris", 
                                   destination => "Londres");
$week-end-amoureux.ajoute_voyageur($_) for <Roméo Juliette Roméo>;
say $week-end-amoureux.perl;
say "Ajoute une note";
$week-end-amoureux.notes = "Eurostar";
say $week-end-amoureux.perl;
say $week-end-amoureux.décrire;

Ce qui affiche :

Roméo est déjà du voyage!  in method ajoute_voyageur at voyage.pl:12
Voyage.new(départ => "Paris", destination => "Londres", notes => Any)
Ajoute une note
Voyage.new(départ => "Paris", destination => "Londres", notes => "Eurostar")
De Paris à Londres - Voyageurs: Roméo Juliette

On constate que le programme avertit à propos du voyageur (Roméo) ajouté par erreur une seconde fois. L'ajout d'une note directement depuis le code appelant ne pose pas de problème, car c'est un attribut public. L'appel de méthode $week-end-amoureux.perl renvoie les seuls attributs publics tandis que l'appel de la méthode décrire permet aussi de connaître le nom des tourtereaux partant en week-end.

Une méthode peut avoir une signature, tout comme une fonction (subroutine). Les attributs sont utilisables dans des méthodes et peuvent toujours être employés avec le twigil «!», même s'ils ont été déclarés avec le twigil «.» (comme dans la méthode décrire de l'exemple ci-dessus). La raison en est qu'en fait, le twigil «.» déclare un twigil «!» et génère en outre un accesseur. Autrement dit, les attributs publics ne sont rien d'autre que des attributs privés dotés d'un accesseur public.

Il y a une différence subtile mais importante entre, par exemple, $!départ et $.départ dans la méthode décrire. Le premier effectue toujours une simple recherche sur la valeur de l'attribut. Cela ne coûte pas grand-chose et vous savez que c'est l'attribut déclaré dans la classe. La seconde syntaxe, avec le «.», est en fait un appel de méthode et peut dont être redéfinie (overriden) dans une classe fille. Il faut par conséquent utiliser uniquement $.départ si l'on désire explicitement autoriser une redéfinition de la méthode.

À l'intérieur d'une méthode, il est possible d'utiliser le terme self qui est lié à l'objet invoquant, c'est-à-dire à l'objet sur lequel la méthode a été invoquée. self peut être utilisé pour appeler d'autres méthodes sur l'invoquant. À l'intérieur d'une méthode, la syntaxe $.point-de-départ est équivalente à self.point-de-départ.

Les méthodes déclarées avec un point d'exclamation «!» sont privées, c'est-à-dire qu'elles ne peuvent être invoquées que depuis l'intérieur de la classe (et non de l'extérieur). On les appelle avec un point d'exclamation au lieu d'un simple point :

method !action-privée($x) {
    ...
}
method publique($x) {
    if self.précondition {
        self!action-privée(2 * $x)
    }
}

Les méthodes privées ne sont pas héritées dans les classes filles.

Une subméthode (submethod) est une méthode publique qui n'est pas héritée dans les classes filles. Leur dénomination émane du fait qu'elles sont sémantiquement équivalentes à des fonctions (subroutines), mais invoquées avec une syntaxe de méthode.

Les subméthodes sont utiles pour accomplir des tâches de construction et de destruction d'objets, ainsi que pour des tâches qui sont si spécifiques à un type donné que les sous-types devront certainement les redéfinir.

Par exemple, le constructeur par défaut new appelle la subméthode BUILD sur chaque classe de la chaîne d'héritage :

class Point2D {
    has $.x;
    has $.y;

    submethod BUILD(:$!x, :$!y) {
        say "Initialise Point2D";
    }
}

class Point2DInversible is Point2D {
    submethod BUILD() {
        say "Initialise Point2DInversible";
    }
    method inverse {
        self.new(x => - $.x, y => - $.y);
    }
}
my $pt_inv =  Point2DInversible.new(x => 1, y => 2);
say $pt_inv.inverse.perl;

Ce qui affiche :

Initialise Point2D
Initialise Point2DInversible
Point2DInversible.new(x => -1, y => -2)

Les classes peuvent avoir des classes mères (ou super-classes).

class Enfant is Parent1 is Parent2 { }

Si l'on appelle sur une classe fille une méthode qui n'est pas définie dans cette classe fille, alors c'est une méthode ayant le même nom dans l'une des classes mères qui sera appelée, si elle existe. L'ordre dans lequel les classes mères sont consultées s'appelle l'ordre de résolution des méthodes (method resolution order ou MRO). Perl 6 utilise la méthode C3 de résolution. Il est possible de connaître cet ordre pour un type donné grâce à un appel à sa métaclasse :

say Int.^mro;    # (Int) (Cool) (Any) (Mu)

Si une classe ne spécifie pas de classe mère, alors la classe Any est sa classe mère par défaut. Toutes les classes héritent directement ou indirectement de Mu, la racine de la hiérarchie des types.

Tous les appels aux méthodes publiques sont virtuels au sens C++ du terme, ce qui signifie que c'est le type réel de l'objet qui détermine quelle méthode invoquer, et non son type déclaré :

class Parent {
    method farfouille {
        say "méthode farfouille de la classe mère"
    }
}

class Enfant is Parent {
    method farfouille {
        say "Appel de la méthode farfouille de la classe fille"
    }
}

my Parent $test;     # type déclaré: Parent
$test = Enfant.new;  # type réel: Enfant
$test.farfouille;    # appelle la méthode farfouille de la classe fille
# affiche :  Appel de la méthode farfouille de la classe fille

Les objets sont généralement créés au moyen d'appels de méthodes, soit sur l'objet-type, soit sur un autre objet de même type.

La classe Mu fournit un constructeur, la méthode new, qui prend en paramètres des arguments nommés et les utilise pour initialiser les attributs publics :

class Point {
    has $.x;
    has $.y = 2 * $!x;   # valeur par défaut de $y si non spécifiée
}

my $p = Point.new( x => 1, y => 2);
#             ^^^ méthode héritée de la classe Mu
say "x: ", $p.x;         # -> x: 1
say "y: ", $p.y;         # -> y: 2

my $p2 = Point.new( x => 5 );
# la valeur sert à calculer $y si l'argument $y n'est pas fourni
# value for y.
say "x: ", $p2.x;        # -> x: 5
say "y: ", $p2.y;        # -> y: 10

Mu.new appelle la méthode bless sur son invoquant et passe tous les arguments nommés. Il est donc possible d'utiliser la méthode de bas niveau bless pour créer ses propres constructeurs sur mesure, mais cela sortirait du cadre de ce tutoriel.

La classe mère Mu, dont héritent toutes les autres classes, fournit une méthode nommée clone qui est quelque peu magique en ce sens qu'elle peut copier des valeurs à partir des attributs privés d'une instance pour créer une nouvelle instance. Cette copie est superficielle, c'est-à-dire qu'elle ne fait que lier les attributs aux valeurs respectives contenues dans l'instance d'origine, elle ne fait pas de copie de ces valeurs contenues.

Comme avec new, il est possible de fournir des valeurs initiales pour les attributs publics et, dans ce cas, ces valeurs l'emportent sur celles provenant de l'instance d'origine. Voici l'exemple fourni dans la documentation de la classe Mu.

class Point2D {
    has ($.x, $.y);
    multi method gist(Point2D:D:) {
        "Point($.x, $.y)";
    }
}

my $p = Point2D.new(x => 2, y => 3);

say $p;                     # Point(2, 3)
say $p.clone(y => -5);      # Point(2, -5)

L'application d'un rôle diffère sensiblement de l'héritage d'une classe. Quand un rôle est appliqué à une classe, les méthodes de ce rôle sont copiées dans cette classe. Si plusieurs rôles sont appliqués à la même classe, d'éventuels conflits (par exemple des attributs ou des méthodes non multiples ayant le même nom) entraînent une erreur de compilation. Laquelle peut être résolue en fournissant une méthode ayant le même nom dans la classe en question.

Ce comportement est bien plus fiable que celui de l'héritage multiple, dans lequel les conflits ne sont jamais détectés par le compilateur, mais résolus silencieusement en prenant la méthode de la classe mère qui apparaît en premier dans le MRO - ce qui est, ou non, ce que désirait le développeur.

Par exemple, si vous avez découvert une nouvelle façon de conduire des vaches et essayez de la commercialiser comme une nouvelle forme populaire de transport, vous aurez peut-être une classe Taureau pour les taureaux que vous élevez, et une classe Automobile pour les choses que vous pouvez conduire.

class Taureau {
    has Bool $.castré = False;
    method mène {
        # Mène votre taurillon au vétérinaire pour le châtrer
        $!castré = True;
        return self;
    }
}
class Automobile {
    has $.direction;
    method mène ($!direction) { }
}
class Taurus is Taureau is Automobile { }

my $t = Taurus.new;
$t.mène; # Castre $t

Avec cette configuration, vos pauvres clients seront dans l'incapacité d'utiliser leur Taurus et vous dans celle de vendre vos produits. Il aurait peut-être été plus judicieux d'utiliser des rôles :

role Taurin {
    has Bool $.castré = False;
    method mène {
        # Mène votre taurillon au vétérinaire pour le châtrer
        $!castré = True;
        return self;
    }
}
role Menable {
    has Real $.direction;
    method mène (Real $d = 0) {
        $!direction += $d;
    }
}
class Taurus does Taurin does Menable { }

Ce code va avorter avec un message du genre :

===SORRY!===
Method 'mène' must be resolved by class Taurus because it exists in
multiple roles (Menable, Taurin)

Cette vérification du compilateur vous épargnera, à vous et à vos clients, beaucoup de migraines à rechercher les causes subtiles d'une anomalie. Ici, vous pourriez simplement définir votre classe comme suit :

class Taurus does Taurin does Menable {
    method mène ($direction?) {
        self.Menable::mène($direction?)
    }
}

Toute tentative d'instancier un rôle (ainsi que diverses autres opérations sur les rôles) créera automatiquement une classe portant le même nom que le rôle, ce qui permet d'utiliser de façon transparente un rôle comme s'il s'agissait d'une classe :

role Point {
    has $.x;
    has $.y;
    method abs { sqrt($.x * $.x + $.y * $.y) }
}
say Point.new(x => 6, y => 8).abs;

Cette création automatique de classe s'appelle punning et la classe générée est un pun. (Le mot anglais pun désigne habituellement un calembour ou un jeu de mots, et punning, c'est faire un jeu de mots ; l'auteur de ces lignes ne voit pas de rapport entre la promotion de rôles au rang de classes et l'idée d'un jeu de mots...).

Perl 6 offre les constructions syntaxiques suivantes pour écrire des regex :

m/abc/;         # une regex immédiatement appliquée à $_
rx/abc/;        # un objet de type Regex
/abc/;          # un objet de type Regex

Les deux premières syntaxes peuvent utiliser d'autres délimiteurs que la barre oblique :

m{abc};         # ou m[abc];
rx{abc};        # ou rx!abc!;

À noter cependant que le caractère deux-points («:») et les parenthèses ordinaires («(» et «)») ne peuvent en principe pas servir de délimiteurs pour des regex.

D'une façon générale, les espaces blancs des motifs sont ignorés par défaut, sauf en cas de l'utilisation (explicite ou implicite) de l'adverbe :s ou :sigspace, voir § 7.1.9.1.2 plus bas) .

say "Reconnu" if "abc" ~~ /a b  c /;    # -> "Reconnu"

Comme dans le reste de Perl 6, les commentaires commencent habituellement avec le caractère dièse ou plus exactement croisillon («#») et vont jusqu'à la fin de la ligne (sauf si le croisillon est utilisé comme délimiteur, auquel cas il est nettement préférable de ne pas essayer de s'en servir comme caractère de début de commentaire). Les commentaires multilignes sont également possibles.

Le cas le plus simple de motif de reconnaissance d'une regex est une chaîne constante. Dans ce cas, reconnaître un motif consiste à rechercher le motif comme une sous-chaîne de la chaîne :

my $chaîne = "Esperluette";  # le nom parfois donné au signe &;
if $chaîne ~~ m/ perl / {
    say "\$chaîne contient 'perl'"; # esperluette contient 'perl'
}

Tous les caractères alphanumériques (Unicode) et le caractère souligné ou underscore («_») sont des reconnaissances littérales. Tous les autres caractères (signes de ponctuation, symboles, etc.) doivent être protégés par le caractère d'échappement antislash («\») ou être cités entre apostrophes (ou guillemets simples) :

/ 'deux mots' /    # reconnaît 'deux mots', espace blanc compris
/ "a:b"       /    # reconnaît 'a:b', caractère deux-points compris
/ '#' /            # reconnaît le caractère dièse (ou hash)
/moi\@gmail\.com/  # échappements pour protéger l'@ et le .

Lorsqu'ils sont protégés par un caractère d'échappement, les caractères alphanumériques prennent une signification particulière : par exemple, le métacaractère \d représente une classe de caractères pouvant signifier un chiffre quelconque (Unicode) ; de nombreux exemples seront donnés plus loin (notamment au § 7.1.3.1).

Les chaînes de caractères sont explorées de gauche à droite, il suffit donc, par exemple, qu'une sous-chaîne soit égale au motif :

if 'abcdefg' ~~ / de / {
    say ~$/;           # de -> motif reconnu
    say $/.prematch;   # abc -> ce qui précède le motif reconnu
    say $/.postmatch;  # fg -> ce qui suit le motif reconnu
    say $/.from;       # 3 -> position du début de la reconnaissance
    say $/.to;         # 5 -> position de ce qui suit la reconnaissance
};

Les résultats de la reconnaissance sont stockés dans la variable $/ (représentant le match object, que l'on traduira dans ce document par « objet reconnu ») et sont également renvoyés par la reconnaissance. Le résultat est de type Match si la reconnaissance a réussi, et Nil (équivalent approximatif de undef en Perl 5) sinon.

Une classe de caractères est un élément de syntaxe des regex qui permet de reconnaître non plus un seul caractère déterminé, mais un caractère appartenant à tout un ensemble de caractères ayant éventuellement des traits communs (reconnaître par exemple l'un quelconque des chiffres de 0 à 9, ou l'un quelconque des caractères alphabétiques minuscules).

Le point («.») reconnaît tout caractère simple (sauf s'il est précédé d'un caractère d'échappement, auquel cas il reconnaît un point littéral) :

'perl'   ~~ /per./;       # Reconnaît toute la chaîne
'perl'   ~~ / per . /;    # Idem (espaces blancs ignorés);
'perl'   ~~ / pe.l /;     # Idem: le . reconnaît le r
'Épelle' ~~ / pe.l/;      # Idem: le . reconnaît le premier l

'perl'   ~~ /. per /      # Pas de reconnaissance: 
                          # le . ne reconnaît rien avant la chaîne per

Contrairement à Perl 5, le point reconnaît aussi toujours le caractère retour à la ligne.

7-1-3-1. Caractère d'échappement et classes de caractères prédéfinies▲

7-1-3-2. Propriétés Unicode▲

'perl6' ~~ m{\w+(<:Ll+:N>)}       # 0 => ｢6｣

7-1-3-3. Classes de caractères énumérées et intervalles▲

"abacabadabacaba" ~~ / <[ a .. d 1 2 3 ]> / # Vrai

say 'pas des guillemets' ~~ /  <-[ " ]> + /;  
      # reconnaît les caractères autres que "

say 'entre guillemets' ~~ / '"' <-[ " ]> * '"'/;
      # un guillemet, suivi de non-guillemets, suivi d'un guillemet

Un quantificateur permet de reconnaître non pas exactement une fois, mais plutôt un nombre fixe ou variable de fois, l'atome qui le précède. Par exemple, le quantificateur «+» cherche à reconnaître une ou plusieurs fois ce qui précède.

Les quantificateurs ont une précédence plus forte que la concaténation, si bien que / ab+ / reconnaît la lettre a suivie d'une ou plusieurs fois la lettre b. La situation est inversée avec des apostrophes : / 'ab'+ / reconnaît les chaînes 'ab', 'abab' 'ababab', etc.

7-1-4-1. Avidité et frugalité des quantificateurs▲

say ~$/ if 'aabaababa' ~~ / .+ b /;      # -> aabaabab

say ~$/ if 'aabaababa' ~~ / .+? b /;     # -> aab

Pour reconnaître une possibilité parmi plusieurs, il faut les séparer par «||» ; la première reconnaissance trouvée (de gauche à droite) l'emporte. Par exemple, les fichiers d'initialisation (du genre config.ini) ont souvent la forme suivante :

[section]
clef = valeur

Quand on lit une ligne d'un fichier de ce genre, ce peut être soit une section, soit une paire clef-valeur. En première approche, la regex pour lire ce type de fichier pourrait être :

/ '[' \w+ ']' || \S+ \s* '=' \s* \S* /

C'est-à-dire :

• soit un mot entre crochets ;
• soit une chaîne composée de caractères autres que des espaces blancs, suivie de 0 ou plusieurs espaces, suivis du signe égal « = », suivi à nouveau d'espaces optionnels, suivi d'une autre chaîne composée de caractères autres que des espaces blancs.

Il existe une autre forme d'alternative, utilisant le séparateur «|» (au lieu de «||»). L'idée est la même, mais c'est la reconnaissance la plus longue (et non plus la première) qui est retenue (voir un exemple de la différence entre ces deux types d'alternatives). C'est cette règle de la reconnaissance la plus longue qui permet par exemple à la grammaire de Perl 6 de reconnaître des identifiants de variables contenant le caractère « - », sans que celui-ci soit confondu avec la soustraction.

Le moteur de regex essaie de trouver une correspondance dans une chaîne en cherchant de gauche à droite.

say so 'Saperlipopette' ~~ / perl /;   # Vrai (True, en fait) 
#         ^^^^
# (so renvoie une évaluation booléenne, donc, en fait True ou False)

Mais ce n'est pas toujours ce que l'on désire. Par exemple, on peut vouloir reconnaître toute la chaîne, ou toute une ligne, ou un ou plusieurs mots entiers, ou attacher de l'importance à l'endroit de la chaîne où la reconnaissance se produit. Les ancres (et les assertions) permettent de spécifier où la reconnaissance aura lieu.

Il faut que les ancres d'une regex soient reconnues pour que l'ensemble de la regex le soit, mais les ancres ne consomment pas de caractère dans la chaîne.

7-1-7-1. Regroupements▲

/ a || b c /        # reconnaît 'a' ou 'bc'
/ ( a || b ) c /    # reconnaît 'ac' ou 'bc'

/ a b+ /            # Reconnaît un 'a' suivi d'un ou plusieurs 'b'
/ (a b)+ /          # Reconnaît une ou plusieurs séquences 'ab'
/ (a || b)+ /       # Reconnaît une séquence quelconque de 'a' et
                    # de 'b' longue d'au moins un caractère

7-1-7-2. Captures▲

my $str =  'nombre 42';
if $str ~~ /'nombre ' (\d+) / {
    say "Le nombre est $0";         # Le nombre est 42
    # ou
    say "Le nombre est $/[0]";      # Le nombre est 42
}

if 'abc' ~~ /(a) b (c)/ {
    say "0: $0; 1: $1";             # 0: a; 1: c
}

if 'abcdef' ~~ /(a) b (c) (d) e (f)/ {
    say $/.list.join: ', ' 
}                                   # -> a, c, d, f

7-1-7-3. Regroupements sans capture▲

if 'abc' ~~ / [a||b] (c) / {
    say ~$0;                # c
}

7-1-7-4. Captures nommées▲

if 'abc' ~~ / $<mon_nom> = [ \w+ ] / {
    say ~$<mon_nom>      # abc
}

if 'décompte=23' ~~ / $<variable>=\w+ '=' $<valeur>=\w+ / {
    my %h = $/.hash;
    say %h.keys.sort.join: ', ';        # valeur, variable
    say %h.values.sort.join: ', ';      # 23, décompte
    for %h.kv -> $k, $v {
        say "Trouvé valeur '$v' avec la clef '$k'";
        # Affiche ces deux lignes :
        #   Trouvé valeur 'décompte' avec la clef 'variable'
        #   Trouvé valeur '23' avec la clef 'valeur'
    }
}

Il est possible de mettre des morceaux de regex dans des sous-règles ou règles nommées, de même que l'on peut mettre des fragments de code dans une fonction (ou subroutine) ou une méthode.

my regex ligne { \N*\n }
if "abc\ndef" ~~ /<ligne> def/ {
    say "Première ligne: ", $<ligne>.chomp;    # Première ligne: abc
}

Une regex nommée peut se déclarer avec la syntaxe my regex nom_regex {corps de la regex }, et appelée ensuite avec <nom_regex>. En outre, invoquer une regex nommée crée ipso facto une capture nommée portant le même nom ($<ligne> dans l'exemple ci-dessus).

Les regex nommées peuvent être regroupées en grammaires (voir § 7.2) et il est souvent souhaitable de le faire (l'objectif des regex nommées est précisément de construire des grammaires).

Il existe des sous-règles prédéfinies, correspondant plus ou moins aux classes de caractères vues antérieurement, par exemple :

• ident : un identifiant ;
• upper : un seul caractère capital ;
• lower : un seul caractère minuscule ;
• alpha : un seul caractère alphabétique ou un caractère souligné «_» (pour un caractère alphabétique Unicode sans le caractère souligné, utiliser <:alpha> ;
• digit : un seul chiffre ;
• punct : un seul caractère ponctuation ;
• alnum : un seul caractère alphanumérique (équivalent à <+alpha +digit>) ;
• wb : limite de mot, assertion de longueur nulle ;

Une liste plus complète se trouve dans le chapitre sur les règles nommées de l'article sur les regex (voir aussi la Synopse S05).

Les adverbes (qui correspondent à ce que l'on appelait modificateurs en Perl 5) modifient la façon dont fonctionnent les regex et permettent des raccourcis très pratiques pour certaines tâches répétitives.

Il y a deux sortes d'adverbes : les adverbes de regex s'appliquent là où la regex est définie et les adverbes de reconnaissance là où le motif reconnaît une chaîne.

7-1-9-1. Adverbes de regex▲

my $rx1 = rx:i/a/;      # avant
my $rx2 = rx/:i a/;     # à l'intérieur

my $rx3 = rx/a :i b/;   # insensible à la casse seulement pour b
my $rx4 = rx/:i a b/;   # complètement insensible à la casse

/ (:i a b) c /          # reconnaît 'ABc' mais pas 'ABC'
/ [:i a b] c /          # reconnaît 'ABc' mais pas 'ABC'

say so 'abc' ~~ / \w+ . /;      # Vrai
say so 'abc' ~~ / :r \w+ . /;   # Faux

my token truc { .... }
# raccourci pour :
my regex truc { :r ... }

say so "J'ai utilisé Photoshop®"  ~~ m:i/   photo shop /; # Vrai
say so "J'ai utilisé photo shop"  ~~ m:i:s/ photo shop /; # Vrai
say so "J'ai utilisé Photoshop®"  ~~ m:i:s/ photo shop /; # Faux

7-1-9-2. Les adverbes de reconnaissance▲

Les assertions permettent de rechercher des correspondances vers l'avant ou vers l'arrière, mais sans consommer la chaîne cible (en restant à la même position), comme le font les ancres.

7-1-10-1. Assertions avant▲

say "tototiti" ~~ rx{ toto <?before titi>};   # -> toto

7-1-10-2. Assertions arrière▲

Une grosse partie de ce qu'il y a besoin de savoir et de comprendre pour écrire une grammaire a déjà été vu ci-dessus, en particulier au chapitre 7.1.8 Sous-règles ou règles nommées, ainsi qu'aux sous-chapitres 7.1.9.1.1 L'adverbe « ratchet » (pas de retour arrière) et 7.1.9.1.2 L'adverbe sigspace (espaces blancs significatifs) ci-dessus. Ces sous-règles ou règles nommées constituent les briques élémentaires d'une grammaire. En fait, l'un des principaux buts d'une grammaire est de regrouper des sous-règles ou regex nommées (de types regex, token et rule) dans un espace de noms bien délimité afin d'éviter les collisions de noms d'identifiants avec d'autres regex ailleurs dans le code.

Rappelons que les règles nommées regex, token et rule sont des entités très semblables servant à déclarer une regex nommée sous une forme ressemblant à la définition d'une fonction ou d'une méthode. Dans ce chapitre, nous les appellerons désormais collectivement règles, indépendamment du mot-clef utilisé pour les déclarer. On les déclare de la façon suivante :

regex ma_regex  { ... }  # regex ordinaire
token mon_token { ... }  # regex avec adverbe :ratchet implicite
rule ma_règle   { ... }  # regex avec :ratchet et :sigspace implicites

Pour mémoire :

• Le mot-clef regex signale une regex ordinaire ;
• Le mot-clef token implique l'adverbe :ratchet (« cliquet ») implicite, c'est-à-dire que ce genre de règle ne fait pas de retour arrière (pas de backtracking) ;
• Le mot-clef rule implique implicitement les adverbes :ratchet (pas de retour arrière) et :sigspace (les espaces du motif ne sont pas ignorés).

Voici un exemple dans lequel on définit une première règle chiffres , et l'utilise pour en définir une seconde, décimal :

my regex chiffres { \d+ }
my regex décimal { <chiffres> \. <chiffres> }
say so " Cet objet coûte 13.45 euros" ~~ /<décimal>/; # -> True
# (so renvoie une évaluation booléenne, donc, en fait True ou False)
say ~$/;                                              # -> 13.45

On voit ci-dessus qu'une règle peut appeler une autre règle, de même qu'une fonction peut appeler une autre fonction. Une règle peut aussi s'appeler elle-même récursivement. Ce mécanisme capital est le cœur de la puissance des regex de Perl 6 et de leur capacité à créer des grammaires.

Une grammaire crée un espace de noms propre et s'introduit avec le mot-clef grammar.

7-2-2-1. Syntaxe de définition d'une grammaire▲

grammar Identité {
    rule nom     { Nom '=' (\N+) } # chaîne de caractères quelconques
                                   # autres que des retours à la ligne
    rule adresse { Adr '=' (\N+) } # idem
    rule âge     { Age '=' (\d+) } # des chiffres

    rule desc {
        <nom>     \n
        <âge>     \n
        <adresse> \n
    }

    # etc.
}

7-2-2-2. Héritage de grammaires▲

grammar Message {
    rule texte     { <salutation> $<corps>=<ligne>+? <fin> }
    rule salutation    { [Salut|Bonjour] $<dest>=\S+? ',' }
    rule fin    { [à|'@'] plus ',' $<auteur>=.+ }
    token ligne    { \N* \n}
}

grammar MessageFormel is Message {
    rule salutation { [Cher|Chère] $<dest>=\S+? ',' }
    rule fin { Bien cordialement ',' $<auteur>=.+ }
}

Il est possible d'analyser une chaîne de caractères avec une grammaire en appelant la méthode .parse sur cette grammaire et en passant optionnellement en paramètre un objet d'actions (voir § XXXX ci-dessous). De même, la méthode .parsefile permet d'analyser un fichier.

MaGrammaire.parse($chaîne, :actions($objet-action))
MaGrammar.parsefile($nom-fic, :actions($objet-action))

Les méthodes .parse et .parsefile sont ancrées au début et à la fin du texte, et échouent si la fin du texte n'est pas atteinte.

En principe, il ne faut utiliser une grammaire que pour effectuer l'analyse lexicale et syntaxique proprement dite du texte. Pour extraire des données complexes, il est recommandé d'utiliser un objet d'actions en conjonction avec la grammaire.

7-2-4-1. Exécuter du code lors d'une reconnaissance ▲

#!/usr/bin/perl6
use v6;

grammar GrammaireTest {
    token TOP { ^ \d+ $ }
}

class ActionsTest {
    method TOP($/) {
        $/.make(2 + ~$/);
    }
}

my $actions = ActionsTest.new;
my $reconnu = GrammaireTest.parse('40', :$actions);
say $reconnu;          # -> ｢40｣
say $reconnu.made;     # -> 42

7-2-4-2. Autres façons d'exécuter du code dans une grammaire▲

grammar toto {
    regex titi { <.configurer> blah blah }
    method configurer {
        # faire quelque chose ici
    }
}

grammar toto {
    regex titi { blah blah { say "Je suis arrivé ici"} blah blah}
}

L'objectif de cet exemple de grammaire est de valider un nom de module Perl.

Le nom d'un module Perl peut se décomposer en identifiants séparés par des paires de caractères deux-points : « :: », par exemple List::Util ou List::MoreUtils (les exemples de noms de modules fournis ici sont des modules Perl 5). Un identifiant doit commencer par un caractère alphabétique ou un caractère souligné, suivi de zéro, un ou plusieurs caractères alphanumériques.

Rien de bien complexe jusqu'ici, mais ceci se complique quelque peu du fait que certains modules ont un seul identifiant (Memoize), et donc pas de caractères deux-points, et que d'autres peuvent avoir des noms « à rallonge » : Regexp::Common::Email::Address.

7-2-5-1. La grammaire de validation▲

grammar Valide-Nom-Module {
    token TOP { ^ <identifiant> [ <séparateur> <identifiant> ]* $}
    token identifiant { 
        <[A..Za..z_]>      # 'mot' commençant par un caractère 
                           # alphabétique ou un caractère souligné 
        <[A..Za..z0..9]>*  # 0 ou plusieurs caractères alphanumériques
    }
    rule séparateur { '::' }    # paire de caractères deux-points
}

for  <Super:Nouveau::Module Super.Nouveau.Module 
      Super::6ouveau::Module Super::Nouveau::Module> -> $nom {
    my $reconnu =  Valide-Nom-Module.parse($nom);
    say "nom\t", $reconnu ?? $reconnu !! "Nom de module invalide";
}

Super:Nouveau::Module   Nom de module invalide
Super.Nouveau.Module    Nom de module invalide
Super::6ouveau::Module  Nom de module invalide
Super::Nouveau::Module  ｢Super::Nouveau::Module｣
 identifiant => ｢Super｣
 séparateur => ｢::｣
 identifiant => ｢Nouveau｣
 séparateur => ｢::｣
 identifiant => ｢Module｣

rule séparateur { '::' || \- }    # deux car. deux-points ou tiret

7-2-5-2. Ajout d'un objet d'actions▲

class Valide-Nom-Module-Actions {
    method TOP($/) {
        if $<identifiant>.elems > 5 {
            warn "Nom de module très long! Peut-être le réduire ?\n"
        }
    }
}

my $reconnu =  Valide-Nom-Module.parse($nom, :actions(Valide-Nom-Module-Actions));

my $nom = "Mon::Module::Super::Cali::Fragi::Listi::Cexpi::Delilicieux";
my $reconnu =  Valide-Nom-Module.parse($nom, :actions(Valide-Nom-Module-Actions));
say $reconnu if $reconnu;

> perl6 grammaire_nom_module.pl
  in method TOP at perl6_grammaire_module.pl:15
｢Mon::Module::Super::Cali::Fragi::Listi::Cexpi::Delilicieux｣
 identifiant => ｢Mon｣
 séparateur => ｢::｣
 identifiant => ｢Module｣
(...)
 identifiant => ｢Delilicieux｣

7-2-5-3. Autres exemples de grammaires▲

La possibilité d'hériter d'une grammaire offre une puissance d'expression insoupçonnée et des perspectives immenses : il est possible, par exemple dans le cadre d'un module, d'écrire une « sous-grammaire » ou grammaire fille de la grammaire de Perl 6 afin de surcharger un opérateur, d'ajouter une fonctionnalité ou même de modifier un élément de la syntaxe, et de faire tourner un programme Perl avec le même compilateur Perl 6 utilisant cette syntaxe localement modifiée.

C'est grâce à ce mécanisme sous-jacent que la syntaxe de Perl 6 est dynamique et, par exemple, qu'il est facile de définir ses propres opérateurs, comme cela a été décrit au § 5 Créer de nouveaux opérateurs.

Il est même possible d'effectuer des modifications de bas niveau de la grammaire de Perl 6 pour aller plus loin et étendre encore plus le langage (voir Modifications de la grammaire et extensibilité du langage).

Les possibilités d'extension sont réellement extraordinaires et stupéfiantes et font de Perl 6 un langage profondément malléable susceptible de rester à la pointe de la technologie des langages pour des décennies.

Une promesse (Promise) représente le résultat d'un calcul qui n'est peut-être pas terminé (voire n'est même pas commencé) au moment où la promesse est obtenue. Les promesses offrent l'essentiel de ce dont a besoin du code utilisateur pour opérer de façon parallèle ou asynchrone.

Un programme peut tenir (keep) sa promesse ou la rompre (break). La promesse peut avoir les statuts (status) « planifié » (Planned), tenu (Kept) ou rompu (Broken).

my $p1 = Promise.new;
say $p1.status;         # -> Planned
$p1.keep('résultat');
say $p1.status;         # -> Kept
say $p1.result;         # -> résultat

my $p2 = Promise.new;
$p2.break('Oh non, pas vrai');
say $p2.status;         # -> Broken
say $p2.result;         # -> "Oh non, pas vrai"

Une bonne partie de la puissance des promesses provient du fait qu'il est possible de les combiner, par exemple de les enchaîner :

my $promesse1 = Promise.new();
my $promesse2 = $promesse1.then(
    -> $v { say $v.result; "Second Résultat"}
);
$promesse1.keep("Premier Résultat");
say $promesse2.result;   # Premier Résultat \n Second Résultat

Ici, le then ordonnance le code (de la promesse 2) en sorte qu'il s'exécute quand la promesse 1 sera tenue ou rompue et renvoie à son tour une nouvelle promesse qui sera elle-même tenue (ou rompue si le code échoue). L'instruction keep fait passer le statut de la première promesse à tenu (Kept), ce qui autorise le démarrage de la seconde promesse.

Il est possible d'ordonnancer une promesse pour qu'elle démarre plus tard :

my $promesse1 = Promise.in(5);
my $promesse2 = $promesse1.then(-> $v { say $v.status; 'Second Résultat' });
say $promesse2.result;