De Perl 5 à Perl 6

Comme en Perl 5 et dans de nombreux autres langages, le signe croisillon (« # ») marque le début d'un commentaire qui s'étend jusqu'à la fin de la ligne. Autrement dit, tout ce qui suit un croisillon sur une ligne est ignoré par le compilateur.

Contrairement à Perl 5 (2), Perl 6 offre aussi la possibilité de faire un commentaire multiligne, ce qui est bien utile quand on désire désactiver temporairement une portion de code posant un problème (cas assez fréquent dans une séance de débogage). Un commentaire multiligne est introduit par la séquence « #` » suivie d'une accolade, d'un crochet ou d'une parenthèse ouvrant, et le commentaire se termine avec l'accolade, le crochet ou la parenthèse (de même type) fermant.

# commentaire uniligne, le compilateur ignore le code de cette ligne

my $pi #`{
Commentaire multiligne: 
Ce commentaire est ouvert avec une accolade ouvrante.
Il faut le fermer avec une accolade fermante.
Si on l'avait ouvert avec un crochet ouvrant,
il faudrait le fermer avec un 
crochet fermant. } = 3.14159;
say "Pi is: $pi";

ce qui affiche à l'exécution :

Pi is: 3.14159

Si l'on désire mettre en commentaire provisoirement du code, cela n'est pas suffisant, car il risque fortement de contenir une accolade fermante (ou un crochet ou une parenthèse). Qu'à cela ne tienne, on peut doubler l'accolade (ou même la tripler), ou utiliser une combinaison crochet-parenthèse (et ainsi de suite) :

use v6;

my $pi #`{{{
Commentaire multiligne: 
Ce commentaire est ouvert avec 3 accolades ouvrantes.
Il faut le fermer avec trois accolades fermantes }.
 }}} = 3.14159;
say "Pi is: $pi";

my $e #`{[
Commentaire multiligne: 
Ce commentaire est ouvert avec une accolade { 
et un crochet.
Il faut le fermer avec un crochet fermant ]
et une accolade fermante }. 
 Ainsi: ]} = 2.71828;
say "e vaut: $e";

my $nb_or = #`({
Autre commentaire multiligne.
On a ouvert avec une parenthese ( et une
accolade {, on ferme avec une accolade }
et une parenthese ), comme suit: }) 1.618;
say "Le nombre d'or est: $nb_or";

Ce qui affiche :

perl6 test_perl6_7.pl
Pi is: 3.14159
e vaut: 2.71828
Le nombre d'or est: 1.618

Il existe une troisième sorte de commentaire, les commentaires documentaires. Ils n'ont pas besoin d'être du code valide, mais, contrairement aux deux formes précédentes de commentaires, ils ne sont pas complètement ignorés par le compilateur, qui garde en mémoire leur contenu pour éventuellement le restituer sur demande. Les deux signes « #= » introduisent un commentaire qui explique certaines choses à propos de la fonction ou de la méthode définie immédiatement après. Le commentaire placé dans ce contexte est accessible via la méthode d'introspection WHY appliquée à ladite fonction ou méthode. En plus de commenter le code comme les autres formes de commentaires, cela peut permettre par exemple de renvoyer à la fonction appelante ou d'imprimer un message explicite sur la syntaxe correcte d'appel.

#= ERREUR. Syntaxe d'appel correcte: ...
sub ma_fonction{
    ...
}

Les chaînes sont mises entre guillemets (ou double quotes), auquel cas l'interpolation des variables a lieu, ou entre apostrophes (ou quotes simples ou single quotes). Le caractère d'échappement barre oblique inversée (« \ », ou antislash ou backslash) fonctionne comme en Perl 5.

Cependant, les règles d'interpolation ont quelque peu changé :

my $scalaire = 6;
my @tableau = 1, 2, 3;
say "Perl $scalaire";         # imprime: 'Perl 6'
say "Un @tableau[]";          # imprime: 'Un 1 2 3'
say "@tableau[1]";            # imprime: '2'
say "Code: { $scalaire * 2 }" # imprime: 'Code: 12'

Les tableaux et tables de hachage ne sont interpolés que s'ils sont suivis d'un indice (ou d'une invocation de méthode se terminant par des parenthèses (par exemple « une obj.methode() »). En cas d'indice vide, c'est l'ensemble de la structure qui est interpolé.

Les variables de type tableau commencent toujours par le sigil « @ ». Mais, contrairement à Perl 5, les tableaux conservent le sigil « @ » même quand on accède à un élément du tableau à l'aide d'un indice.

my @a = 5, 1, 2;# les parenthèses ne sont plus nécessaires
say @a[0];      # Oui, ça commence avec une @
say @a[0, 2];   # les tranches de tableau fonctionnent comme en Perl 5

Les listes se construisent avec l'opérateur virgule. « 1, » est une liste, mais « (1) » n'en est pas une.

Comme tout est objet en Perl 6, il est possible d'appeler des méthodes sur les tableaux :

my @b = @a.sort;
@b.elems;                   # nombre d'éléments
if @b > 2 { say "yes" }     # fonctionne toujours
@b.end;                     # indice du dernier élément. Remplace $#b
my @c = @b.map({$_ * 2 });  # Oui, map est aussi une méthode.

Il y a une forme plus brève pour remplacer l'ancienne construction de citation qw / .../ ;

my @methods = <shift unshift push pop end delete sort map>;

Vues en contexte de liste, les tables de hachage de Perl 5 sont des listes ayant un nombre pair d'éléments. Dans ce même contexte, les tables de hachage de Perl 6 sont des listes de paires (d'objets de type Pair). La différence peut paraître subtile, mais elle est réelle. Les paires sont utilisées pour faire d'autres choses en Perl 6, comme les arguments nommés d'une fonction, mais nous y reviendrons plus loin.

De même que pour les tableaux, le sigil « % » reste invariant quand on accède à un élément individuel d'un hachage. Et les hachages ont également des méthodes telles que keys et values que l'on peut invoquer sur eux.

my %boissons =
    France  => 'Vin',
    Angleterre => 'Tea',
    USA     => 'Coke';

say "Boisson favorite en France : ",  %boissons{'France'};
say "Pays: ", %boissons.keys.sort;
say "Boissons: ", %boissons.values.sort;

Ce qui affiche :

Boisson favorite en France : Vin
Pays: Angleterre France USA
Boissons: Coke Tea Vin

À noter que quand on accède aux éléments d'un hachage avec la syntaxe %hash{...}, la clef n'est pas mise implicitement entre guillemets comme en Perl 5. En fait, %hash{toto} n'accède pas à la clef « toto » du hachage, mais appelle la fonction toto(). Le mécanisme de mise implicite entre guillemets ne disparaît pas pour autant, il obéit seulement à une syntaxe modifiée :

say %boissons<Angleterre>;     # imprime 'Tea'

L'opérateur each (partiellement bogué et peu fiable en Perl 5) est remplacé par l'opérateur pairs, qui retourne les paires du hachage :

my %hash = qw (jan  1 fev 2 mar 3 avr 4 mai 5 jun 6);
say %hash;    # imprime: {avr => 4, fev => 2, jan => 1, jun => 6, 
              #           mai => 5, mar => 3} 
              # Remarque: l'ordre n'est pas préservé

say values %hash;    # imprime (4 1 3 6 2 5)
say %hash.keys;      # imprime (avr jan mar jun fev mai)
say $_ for %hash.pairs;

La dernière ligne de code ci-dessus, qui pourrait aussi s'écrire say $_ for pairs %hash; , affiche :

avr => 4
jan => 1
mar => 3
jun => 6
fev => 2
mai => 5

ce qui montre bien l'existence réelle de paires, puisque la variable $_ reçoit bien successivement chaque paire avant de l'afficher.

Si l'on a déclaré une chose d'un certain type, on peut être sûr de pouvoir faire certaines opérations dessus. Il n'y a pas besoin de vérifier.

Si l'on a les informations de type à la compilation, certaines optimisations sont possibles. Il n'y a en principe pas de raison que Perl soit plus lent que le C.

Avec les informations de type et les répartitions multiples, il est possible de raffiner certains opérateurs pour des types particuliers.

L'instruction if est essentiellement inchangée, vous pouvez toujours y ajouter des opérations de branchement elsif ou else. L'instruction unless est toujours là, mais il n'est pas autorisé d'y adjoindre un else.

my $mouton = 42;
if $mouton == 0 {
    say "Comme on s'ennuie";
} elsif $mouton == 1 {
    say "Un mouton solitaire";
} else {
    say "Un troupeau, super!";
}

Il est toujours possible de placer un if ou un unless après une instruction, en tant que modificateur d'instruction :

say "Vous avez gagné!" if $reponse == 42;

Perl 6 offre des constructions dont pratiquement tout programmeur (quel que soit le langage) a dû rêver au moins une fois dans sa vie, surtout quand il débutait. Si l'on veut comparer trois variables, en Perl 5 (et dans la quasi-totalité des autres langages), il faut faire deux comparaisons distinctes reliées par un opérateur booléen :

my $c = my $d = my $e = 10;
print "Vrai\n" if $c == $d and $d == $e;
print "Vrai\n" if $c < 13 and $c > 7;

Nous en avons tous rêvé, Perl 6 l'a fait. En Perl 6, on peut chaîner les opérateurs et écrire beaucoup plus simplement et surtout plus naturellement :(4)

my $c = my $d = my $e = 10;
say "Vrai" if $c == $d == $e;  # imprime Vrai
say "Vrai" if 13 > $c > 7;     # imprime Vrai

On peut modifier l'exécution d'une boucle avec les opérateurs next et last, comme en Perl 5.

La boucle for est maintenant utilisée exclusivement pour itérer sur des listes. Elle utilise par défaut la variable $_ topicalisée, sauf si une variable de boucle explicite est fournie :

for 1..10 -> $x {
    say $x;   # imprime les nombres de 1 à 10
}

La construction -> $x { ... } s'appelle un « pointy block » (un « bloc pointu ») et est analogue à une fonction (ou fermeture) anonyme ou à un lambda en Lisp. Par défaut, le paramètre d'un bloc pointu est un alias en lecture seule (non modifiable) des valeurs successives du tableau.

my @list = 1..10;
for @list -> $x {
     $x++;    # erreur ! $x est en lecture seule
}

Il est possible de rendre les valeurs modifiables en utilisant un doubly pointy block (bloc « doublement pointu ») :

my @list = 1..10;
for @list <-> $x {
     $x++;
}
say $_ for @list ;    # imprime les nombres de 2 à 11

Vous pouvez même utiliser plusieurs variables de boucle :

for 0..5 -> $pair, $impair {
    say "Pair: $pair \t Impair: $impair";
}

Ce qui affiche bien :

Pair: 0          Impair: 1
Pair: 2          Impair: 3
Pair: 4          Impair: 5

Cette syntaxe offre aussi un bon moyen d'itérer sur les couples clef/valeur de hachages :

my %h = a => 1, b => 2, c => 3;
for %h.kv -> $clef, $valeur {
    say "$clef: $valeur";
}

Ce qui affiche :

a: 1
b: 2
c: 3

La boucle for de style C a changé de nom et s'appelle désormais loop (et c'est la seule construction de boucle nécessitant encore des parenthèses). Plus encore qu'en Perl 5, ce style de boucle est à réserver à des cas bien particuliers sur la condition d'arrêt de la boucle ou la façon dont est modifiée la variable de boucle :

loop (my $x = 2; $x < 100; $x = $x**2) {
    say $x;
}

Ce qui affiche :

2
4
16

Si vous appelez une fonction avec la syntaxe suivante :

ma_fonction($param1, $param2);

L'argument $param1 est lié au premier paramètre formel, et l'argument $param2 au second paramètre, et ainsi de suite. C'est ce que l'on appelle des paramètres positionnels, l'affectation des paramètres dans la fonction appelée dépend de l'ordre dans lequel la liste de paramètres est passée.

Il est parfois plus facile de se souvenir de noms plutôt que de numéros d'ordre (surtout si la liste des paramètres est un peu longue). C'est pourquoi Perl 6 a des paramètres nommés(6) :

my $r = Rectangle.new( 
        x         => 100, 
        y         => 200, 
        hauteur   => 23,
        largeur   => 42,
        couleur   => 'black'
);

Quand vous voyez ceci, vous savez immédiatement ce que signifie chaque argument spécifique. Pour définir un paramètre nommé, il suffit de le préfixer du signe deux-points (« : ») dans la liste de signature :

sub aire(:$largeur, :$hauteur) {
    return $largeur * $hauteur;
}
aire(largeur => 2, hauteur => 3);
aire(hauteur => 3, largeur => 2 ); # même chose
aire(:hauteur(3),  :largeur(2));    # idem

Le dernier exemple utilise la syntaxe dite de paire à deux-points (colon pair syntax). Si on omet la valeur, cela lui donne une valeur vraie (True) par défaut, et si l'on utilise l'opérateur de négation « ! », la valeur devient fausse (False) :

:dessine_perimetre  # équivalent à "dessine_perimetre => True"
:!transparent       # équivalent à "transparent => False"

Dans la déclaration des paramètres nommés dans la fonction aire ci-dessus, le nom de la variable est également le nom de l'argument. Il est cependant possible d'employer un autre nom :

sub aire(:largeur($l), :hauteur($h)){
    return $l * $h;
}
say aire(largeur => 2,  hauteur => 3); # imprime 6

Le fait de donner une signature à une fonction ne signifie pas qu'il faille connaître à l'avance le nombre des arguments. Il est possible d'utiliser des paramètres optionnels (parfois appelés « slurpy parameters », ou paramètres « gobe-tout »). Ce genre de paramètre doit être placé après les paramètres réguliers obligatoires et utilise toute la liste restante des arguments :

sub ma_fonction ($param1, *@reste){
    say "Premier: $param1";
    say "Reste: @reste[]";
}
ma_fonction(1, 2, 3, 4);

Ce qui affiche :

Premier: 1
Reste: 2 3 4

Les paramètres nommés par défaut sont déclarés en utilisant un astérisque devant le paramètre hachage :

sub commande-repas($plat, *%extras) {
    say "Je désire un $plat, mais avec quelques modifications:";
    say %extras.keys.join(', ');
}

commande-repas('steak', :oignons, :bien-cuit);

Ce qui affiche :

Je voudrais un steak, mais avec quelques modifications:
oignons, bien-cuit

Par défaut, les tableaux ne sont pas interpolés dans les listes d'arguments (ils ne sont pas « aplatis » en une liste unique). Donc, contrairement à Perl 5, on peut écrire :

sub a($scalaire1, @liste, $scalaire2) {
    say $scalaire2;
}

my @liste = "toto", "titi";
a(1, @liste, 2); # imprime 2

Mais cela signifie aussi qu'il n'est pas possible, par défaut, d'utiliser un tableau comme une liste d'arguments passés à une fonction :

my @indexes = 1, 4;
say "abcdefgh".substr(@indexes); # pas ce que l'on veut

Contrairement à ce que l'on pourrait penser, cela n'affiche pas « bcde » (comme le ferait say "abcdefgh".substr(1, 4);, mais « cdefgh ».

Ce qui se passe ici est que le premier argument de la méthode substr est censé être un Int, et la coercition fait que substr reçoit en définitive un seul argument, le nombre d'éléments du tableau @indexes et la fonction retourne la fin de la chaîne à partir du troisième caractère.

Pour obtenir le comportement voulu, il faut utiliser le préfixe « | » (ou hyperopérateur) devant le nom du tableau :

say "abcdefgh".substr(|@indexes); # imprime bcde 
say "abcdefgh".substr(1, 4);      # même chose

Il est possible de définir des fonctions multiples (multi subs) ayant le même nom, mais une signature ou liste de paramètres différente, en utilisant le mot-clef multi :

multi sub my_substr($str) { ... }                          # 1
multi sub my_substr($str, $start) { ... }                  # 2
multi sub my_substr($str, $start, $end) { ... }            # 3
multi sub my_substr($str, $start, $end, $subst) { ... }    # 4

Lorsque l'on appelle la fonction my_substr(), c'est celle ayant le nombre de paramètres correspondant à l'appel qui sera appelée.

Les multi n'ont pas besoin de se distinguer par leur arité (nombre de paramètres), elles peuvent aussi différer par le type des arguments employés.

multi sub util(Str $s) { say "Utilisation de la chaîne $s"  }
multi sub util(Int $i) { say "Utilisation de l'entier $i" }

util("x");      # Utilisation de la chaîne x
util(2);        # Utilisation de l'entier 2

On déclare les méthodes avec le mot-clef method. À l'intérieur d'une méthode, il est possible d'utiliser le terme self pour se référer à l'objet sur lequel la méthode a été appelée (l'invocateur).

On peut également donner un autre nom à l'invocateur en ajoutant un premier paramètre à la liste de signature et en le postfixant avec un caractère deux-points, « : ».

method faire ($x: $a, $b, $c) { ... } # $x représente l'invocateur

On peut appeler une méthode publique avec la syntaxe $object.method si la méthode ne prend pas d'argument et avec les syntaxes $object.method(@args) (notation pointée) ou $object.method: @args (notation indirecte) si elle doit recevoir des arguments.

class SomeClass {
    # ces 2 méthodes ne font rien d'autre que retourner l'invocateur
    method foo {
        return self;
    }
    method bar(SomeClass $s: ) {
        return $s;
    }
}
my SomeClass $x .= new;
$x.foo;          # même chose que $x
$x.bar;          # pareil
$x.foo.bar ;     # idem

La syntaxe my SomeClass $x .= new; n'est en fait qu'un raccourci pour my SomeClass $x = SomeClass.new;. Cela marche parce la déclaration de type fait de la variable un objet de type SomeClass, qui est un objet représentant la classe.

Les méthodes peuvent recevoir des arguments supplémentaires, comme les fonctions.

Les méthodes privées sont marquées comme telles à l'aide d'un point d'exclamation (« ! »). Elles se déclarent avec la syntaxe methode!methodenameet s'appellent avec la syntaxe self!method_name.

class Foo {
    method !private($toto) {
        return "Reçu le param $toto";
    }

    method publique {
        say self!private("foo");
    }
}
my Foo $x .= new;
$x.publique;  # imprime "Reçu le param foo"

Les méthodes privées ne peuvent être appelées que depuis l'intérieur de la classe.

Les attributs se déclarent avec le mot-clef has et ont un twigil, c'est-à-dire un second caractère spécial après le sigil. Pour les attributs privés, c'est le point d'exclamation (« ! »), pour les attributs publics, c'est le point (« . »). Les attributs publics ne sont autre chose que des attributs privés dotés d'un accesseur public. Donc, pour modifier un attribut, il faut utiliser le sigil « ! » pour accéder à l'attribut réel, et non l'accesseur, sauf si l'accesseur est doté de la propriété is rw.

class SomeClass {
    has $!a;
    has $.b;
    has $.c is rw;

    method set_stuff {
        $!a = 1;    # OK, écriture dans l'attribut depuis la classe
        $!b = 2;    # idem
        $.b = 3;    # ERREUR, ne peut écrire sur un accesseur RO
    }

    method do_stuff {
        # on peut utiliser le nom public ou le nom privé
        # $!b et $.b sont vraiment la même chose
        return $!a + $!b + $!c;
    }
}
my $x = SomeClass.new;
say $x.a;       # ERREUR!
say $x.b;       # OK
$x.b = 2;       # ERREUR!
$x.c = 3;       # OK

L'héritage est réalisé à l'aide du trait is.

class Foo is Bar { 
    # la classe Foo hérite de la classe Bar
    ...
}

Toutes les règles communes d'héritage s'appliquent. Les méthodes sont d'abord recherchées dans la classe directe de l'objet, puis, si elle n'y est pas trouvée, dans la classe parente (et ainsi de suite récursivement). De même, le type d'une classe enfant est conforme à celui d'une classe parente :

    class Bar { }
    class Foo is Bar { }
    my Bar $x = Foo.new();   # ok, car Foo ~~ Bar

Dans cet exemple, le type de l'objet $x est Bar, et il est licite de lui affecter un objet de type Foo, car « tout Foo est un Bar ».

Les classes peuvent hériter d'autres classes multiples :

class ArrayHash is Hash is Array { 
    ...
}

Cela dit, l'héritage multiple pose de multiples problèmes, et est souvent déconseillé. Les rôles constituent souvent un choix plus fiable.

En général, le monde n'est pas hiérarchique, et il est donc souvent difficile de tout faire entrer dans une hiérarchie d'héritage. C'est l'une des raisons pour laquelle Perl 6 instaure des rôles(7). Un rôle regroupe des comportements qui peuvent être partagés par différentes classes. Un rôle est assez semblable à une classe, mais la grande différence est qu'il n'est pas possible d'instancier des objets directement à partir de rôles. En outre, la composition de rôles multiples ayant les mêmes noms de méthodes génère des conflits au lieu de se résoudre silencieusement à l'une d'entre elles, comme c'est le cas avec l'héritage multiple.

Tandis que les classes ont pour principal objectif la conformité des types, les rôles sont en Perl 6 surtout un moyen de réutiliser du code.

role Dessinable {
    has $.couleur is rw;
    method dessiner { ... }
}
class Forme {
    method aire { ... }
}

class Rectangle is Forme does Dessinable {
    has $.largeur;
    has $.hauteur;
    method aire {
        $!largeur * $!hauteur;
    }
    method dessiner() {
        for 1..$.hauteur {
            say 'x' x $.largeur;
        }
    }
}

Rectangle.new(largeur => 8, hauteur => 3).dessiner;

Ce qui affiche le rectangle :

~ perl6 test_rectangle.pl
xxxxxxxx
xxxxxxxx
xxxxxxxx

http://perlcabal.org/syn/S12.html http://perlcabal.org/syn/S14.html http://www.jnthn.net/papers/2009-yapc-eu-roles-slides.pdf http://en.wikipedia.org/wiki/Perl_6#Roles

Annexe 2 : Programmation objet en Perl 6

Objets, classes et rôles en Perl 6 - Tutoriel de programmation orientée objet

Au tout début de Perl 6, de nombreux opérateurs avaient deux versions, une qui retournait une simple liste « aplatie » et une autre qui renvoyait une liste de tableaux.

Ceci a été provisoirement résolu en renvoyant une liste d'objets de type Parcel (paquet), et les parcels pouvaient s'aplatir ou non, selon le contexte.

À l'époque où nous avions initialement rédigé ce tutoriel (automne 2014), nous avions le comportement suivant :

# Ancien comportement, Perl 6 ne fonctionne plus comme cela aujourd'hui
> my @tableau = 1,(2,3),4;
1 2 3 4
> @tableau.elems;
4

On voit que l'affectation à un tableau conduisait à l'« aplatissement » de la liste (comme en Perl 5). Dans d'autres cas, les listes conservaient leur structure.

Il s'est avéré que ce comportement n'était pas satisfaisant pour toute une série de raisons (problèmes de performance, caractère contre-intuitif, etc.). En 2015, la spécification des listes a été revue de fond en comble lors du Great List Refactor (GLR, grande refonte des listes). Le type de donnée Parcel a été abandonné et les listes ne sont généralement plus aplaties (sauf si on le demande explicitement) :

my @tableau = 1, (2, 3), 4;
[1 (2 3) 4]
> @tableau.elems;
3

Le tableau @tableau contient maintenant trois éléments, dont le second est lui-même une liste de deux éléments, (2, 3).

De même, contrairement à Perl 5,il n'y a pas d'aplatissement de la structure si l'on fusionne deux tableaux :

my @a = 1, 2;
my @b = 3, 4, 5;
my @c = @a, @b;     # structure préservée
say @c.perl;        # [[1, 2], [3, 4, 5]]

Il reste possible d'aplatir explicitement une liste à l'aide de l'opérateur préfixé «|» ou de la méthode flat :

> my @tableau =  (1, |(2,3), 4);
[1 2 3 4]

> my @tableau = (1, (2, 3), 4).flat;
[1 2 3 4]
> @tableau.elems;
4

flat admet aussi une syntaxe de fonction et permet de joindre des tableaux comme en Perl 5 :

my @a = 1, 2;
my @b = 3, 4, 5;
@c = flat @a, @b;
say @c.perl;        # [1, 2, 3, 4, 5]

De même, avant la GLR, le fragment de code suivant :

> say (10,(11,12,13),(14,15))[2]
(14 15)

Aurait renvoyé 12.

Considérons l'opérateur Z (lettre capitale Z, abréviation de zip) qui alterne les éléments de deux listes :

> my @tableau = <a b c> Z <1 2 3>;
[(a 1) (b 2) (c 3)]

Avant la GLR, le tableau aurait été constitué de six éléments individuels en raison de l'aplatissement de la liste créée lors de l'affectation. Il contient maintenant trois listes imbriquées. Ceci permet par exemple d'accéder aux sous-listes :

my @tableau = <a b c> Z <1 2 3>;
for @tableau -> $paire {
    say "premier: $paire[0]  second: $paire[1]"
}

Ce qui affiche :

premier: a  second: 1
premier: b  second: 2
premier: c  second: 3

Bien sûr, si l'on désire obtenir une liste simple d'éléments individuels, il suffit d'aplatir la liste produite par l'opérateur zip :

> my @tableau = (<a b c> Z <1 2 3>).flat;
[a 1 b 2 c 3]

Les caractères de type alphanumériques (c'est-à-dire les lettres, le souligné « _ », les chiffres et tous les caractères Unicode) sont reconnus littéralement (ils établissent une correspondance avec eux-mêmes) et peuvent prendre une signification particulière (dite métasyntaxique) lorsqu'ils sont préfixés d'une barre oblique inversée (backslash ou antislash). Pour tous les autres caractères, c'est exactement l'inverse : ce sont des métacaractères sauf s'ils sont préfixés d'un backlash.

Les symboles métasyntaxiques n'ont pas tous une signification (pour l'instant). Il est illicite d'employer ceux qui n'ont pas une signification dûment définie.

Il y a une autre façon de redonner leur sens littéral aux caractères métasyntaxiques des chaînes dans les regex, avec les apostrophes :

m/'a texte littéral: $#@!!'/

Le changement de sémantique du point « . » a déjà été mentionné, ainsi que la nouvelle construction [...] pour les groupes non capturants. Les classes de caractères s'écrivent <[...]> et la négation d'une classe <-[...]>. ^ et $ reconnaissent toujours respectivement le début et la fin de la chaîne, alors que l'on emploie ^^ et $$ pour reconnaître le début et la fin d'une ligne. Cela signifie que les modificateurs /s et /m sont désormais inutiles et ont disparu.

Les modificateurs (ou adverbes) préfixent désormais la regex et utilisent la notation suivante :

if "abc" ~~ m:i/B/ {
    say "Reconnu!";
}

… qui se trouve être la même chose que la syntaxe de paire à deux-points (colon pair) utilisée pour passer des arguments nommés à des fonctions (§ 5.2.1).

Le comportement introduit en Perl 5 par le modificateur /x est maintenant le fonctionnement par défaut ; autrement dit, les espaces blancs sont ignorés.

Les modificateurs ont une forme courte et une forme longue.

Le:sigspace (ou:s) nécessite une petite explication. Il remplace tous les espaces du motif par <.ws> (c'est-à-dire qu'il appelle la règle ws sans conserver le résultat). Cette règle peut être annulée. Par défaut, il reconnaît un ou plusieurs espaces blancs s'il est encadré de caractères alphanumériques, et zéro ou plusieurs blancs dans le cas contraire.

(Il y a d'autres nouveaux modificateurs, mais sans doute pas aussi importants que ceux énumérés ci-dessus.)

Chaque reconnaissance génère un objet reconnu (match object), qui est contenu dans la variable spéciale $/. C'est une chose versatile. En contexte booléen, il retourne Bool::True (vrai) si la reconnaissance a réussi. En contexte de chaîne de caractères, il renvoie la chaîne reconnue. En contexte de liste, il renvoie les chaînes capturées dans l'ordre des captures, et en contexte de hachage, il renvoie des captures nommées. Les méthodes .from et .to donnent respectivement la position dans la chaîne du début et de la fin de la reconnaissance.

if 'abcdefg' ~~ m/(.(.)) (e | bla ) $<foo> = (.) / {
    say $/[0][0];           # d
    say $/[0];              # cd
    say $/[1];              # e
    say $/<foo>             # f
}

$0, $1, etc. sont simplement des alias pour $/[0], $/[1], etc. De même, $<x> est un alias vers $/<x> et $/{'x'}.

À noter que tout ce que l'on peut accéder avec $/[...] et $/{...} est à nouveau un objet reconnu (ou une liste d'objets reconnus). Cela permet de vrais arbres d'analyse syntaxique (parsing) avec des règles.

Les regex peuvent être utilisées de la façon traditionnelle, m/.../, ou être déclarées comme des fonctions ou des méthodes :

regex a { ... }
token b { ... }
rule  c { ... }

La différence est qu'un token (unité lexicale) implique le modificateur:ratchet (ce qui signifie pas de retour arrière, comme si le motif avait le modificateur (?> … ) en Perl 5) et qu'une rule (règle) implique à la fois:ratchet et:sigspace.

Pour appeler une telle règle (nous appellerons les trois entités ci-dessus règles, indépendamment du mot-clef utilisé pour les déclarer), on met son nom entre des chevrons (signes inférieur à « < » et supérieur à « > », ou angle brackets) : <a>. Ceci ancre implicitement la règle à sa position actuelle dans la chaîne de caractères et place le résultat dans l'objet reconnu à l'emplacement $/<a>, autrement dit, c'est une capture nommée. Il est également possible d'appeler une règle sans capturer le résultat en préfixant son nom d'un point : <.a>.

Une grammaire est un groupe de règles permettant de construire progressivement un système de reconnaissance de texte beaucoup moins bien structuré que ce que l'on peut reconnaître avec les expressions régulières (même étendues) de Perl 5.

Voici par exemple une grammaire sommaire décrivant l'identité d'une personne (adaptée de la Synopsis S05 du langage) :

grammar Personne {
    rule nom { Nom '=' (\N+) }   # \N : caractère non fin de ligne
    rule age { Age '=' (\d+) }   # un ou plusieurs chiffres
    rule adr { Adr '=' (\N+) }
    rule desc {
        <nom> \n
        <age>  \n
        <adr> \n
    }
    # etc.
}

L'exemple fourni au début de ce chapitre (§ 8.1) donne un exemple de grammaire (sans doute quelque peu simpliste) permettant de reconnaître une URL. Autant il n'était pas vraiment recommandé d'utiliser les expressions régulières de Perl 5 pour reconnaître une URL, autant les grammaires permettent d'effectuer une réelle analyse lexicale et syntaxique du texte analysé pour détecter ou confirmer une URL. Et même s'attaquer à des problèmes bien plus complexes (analyser du HTML, du XML et même du code source informatique).

Les grammaires fonctionnent de façon semblable aux classes. En particulier, les grammaires peuvent hériter des règles d'une autre grammaire, en surcharger d'autres, et ainsi de suite.

grammar Courriel {
    rule texte       { <debut> $<corps>=<ligne>+? <salutation> }
    rule debut       { [Salut|Bonjour|Hi|Hey] $<to>=\S+? ',' }
    rule salutation  { A plus ',' $<from>=.+ }
    token ligne      { \N* \n}
}
grammar CourrielOfficiel is Courriel {
    rule debut       { Cher $<to>=\S+? ',' }
    rule salutation  { Bien cordialement ',' $<from>=.+ }
}