Introduction à Perl 6

Perl 6 est un langage de haut niveau, générique et dynamique. Il supporte plusieurs paradigmes dont : la programmation procédurale, la programmation orientée objet et la programmation fonctionnelle.

La devise de Perl 6 :

• TMTOWTDI (prononcé Tim Toady) : There is more than one way to do it: c'est-à-dire « Il y a plus d'une façon de le faire ».
• Easy things should stay easy, hard things should get easier, and impossible things should get hard: « Les choses faciles doivent rester faciles, les choses difficiles devraient devenir plus faciles, et les choses impossibles devraient devenir difficiles ».

Un programme ou script Perl 6 est un fichier texte qui sera compilé et exécuté par l'exécutable perl6 et la machine virtuelle associée (par exemple MoarVM ou JVM).

• Perl 6 est une spécification de langage avec une suite de tests. Les implémentations qui passent la suite de tests sont considérées comme du Perl 6.
• Rakudo est un compilateur pour Perl 6.
• Rakudobrew est un gestionnaire d'installation pour Rakudo.
• Panda est un installeur de modules pour Perl 6.
• Rakudo Star est un paquet qui comprend : Rakudo, Panda, une collection de modules, et de la documentation.

Linux

1. Installez Rakudobrew : https://github.com/tadzik/rakudobrew.
2. Installez Rakudo : tapez la commande suivante dans le terminal rakudobrew build moar.
3. Installez Panda : tapez la commande suivante dans le terminal rakudobrew build panda.

OS X

Quatre solutions possibles :

• Suivez les mêmes étapes que celles indiquées pour l'installation sur Linux, ou
• Installez avec homebrew : brew install rakudo-star, ou
• Installez avec MacPorts : sudo port install rakudo, ou
• Téléchargez l'installateur (fichier avec l'extension .dmg) depuis http://rakudo.org/downloads/star/

Windows

1. Téléchargez l'installeur le plus récent (fichier avec une extension .MSI) de http://rakudo.org/downloads/star/.
   Si votre système possède une architecture 32 bits, téléchargez le fichier x86. S'il possède une architecture 64 bits, téléchargez le fichier x86_64.
2. Après l'installation, ajoutez C:\rakudo\bin à votre PATH.

Docker

1. Obtenez l'image officielle docker pull rakudo-star.
2. Ensuite exécutez dockerrun -it rakudo-star.

On peut exécuter du code Perl 6 en utilisant le terminal Perl 6 interactif REPL (Read-Eval-Print Loop). Pour ce faire, ouvrez un terminal, tapez perl6 dans la fenêtre de terminal et ensuite la touche [Entrée].
Une invite de commande > apparaîtra.
Ensuite, tapez une ligne de code puis la touche [Entrée]. Le REPL affichera la valeur de la ligne interprétée. Vous pouvez taper une autre ligne, ou exit et ensuite [Entrée] pour sortir du REPL.

L'autre façon consiste à écrire votre code dans un fichier, le sauvegarder puis l'exécuter. Il est conseillé, pour plus de clarté, que les scripts Perl 6 portent l'extension .pl6. Exécutez le fichier en entrant perl6 nom-du-fichier.pl6 dans la fenêtre de terminal (puis [Entrée]).
À l'inverse du REPL, le résultat ne sera pas automatiquement affiché pour chaque ligne : le code doit contenir une instruction comme say ou print pour afficher une sortie.

Le REPL est la plupart du temps utilisé pour essayer un morceau de code, le plus souvent une seule ligne. Pour des programmes de plus d'une seule ligne, la méthode fichier/exécution est recommandée.

Les lignes de code unilignes peuvent aussi être entrées de façon non interactive sur la ligne de commande en tapant perl6 -e 'mon code ici' et ensuite [Entrée].

Comme la plupart du temps, nous allons écrire et stocker nos programmes en Perl 6 dans des fichiers, nous devrions avoir un éditeur de texte décent qui reconnaît la syntaxe de Perl 6.

Je recommande personnellement Atom. C'est un éditeur de texte moderne livré avec une coloration syntaxique pour Perl 6. Perl6-fe est une coloration syntaxique alternative pour Perl 6 sur Atom, basée sur l'originale, mais comprenant de nombreux correctifs et ajouts.

D'autres personnes de la communauté utilisent aussi Vim, Emacs ou Padre.

Les versions récentes de Vim sont livrées avec la coloration syntaxique pour Perl 6. Emacs et Padre nécessiteront l'installation de paquets supplémentaires.

Nous allons commencer avec le rituel hello world.

say 'Bonjour Monde';

qui peut aussi s'écrire:

'Bonjour Monde'.say;

Perl 6 a une forme libre : vous êtes libre (la plupart du temps) d'utiliser n'importe quelle quantité d'espaces.

Les instructions sont typiquement une ligne logique de code, elles doivent se terminer par un point-virgule :
say "Hello" if True;

Les expressions sont un type spécial d'instructions qui retournent une valeur :
1+2 retourne 3

Les expressions sont faites de termes et d'opérateurs.

Les termes sont des :

• variables : une valeur qui peut être manipulée ou changée ;
• valeurs littérales : une valeur constante comme un nombre ou une chaîne.

Les opérateurs sont classés en types :

1-7-1. Identificateurs▲

1-7-2. Commentaires▲

=begin comment
Ceci est un commentaire sur plusieurs lignes.
Commentaire 1
Commentaire 2
=end comment

1-7-3. Guillemets▲

say 'Bonjour Monde';             # Bonjour Monde
say "Bonjour Monde";             # Bonjour Monde
say "Quelqu'un m'a dit";         # Quelqu'un m'a dit
my $nom = 'François Pinon';
say 'Salut $nom';                # Salut $nom
say "Salut $nom";                # Salut François Pinon

say 'Quelqu\'un m\'a dit';       # Quelqu'un m'a dit

Un scalaire contient une valeur ou une référence.

#String
my $nom = 'François Pinon';
say $nom;

#Integer
my $age = 20;
say $age;

Certaines opérations peuvent être effectuées sur un scalaire, suivant le type de valeur qu'il contient.

Chaîne

my $nom = 'François Pinon';
say $nom.uc;
say $nom.chars;
say $nom.flip;

ce qui affiche :

FRANÇOIS PINON
14
noniP sioçnarF

Entier

my $age = 17;
say $age.is-prime;

Ce qui affiche :

True

Nombre rationnel

my $age = 2.3;
say $age.numerator;
say $age.denominator;
say $age.nude;

Ceci affiche :

23
10
(23 10)

Les tableaux sont des listes contenant plusieurs valeurs. Par défaut, les valeurs d'un tableau peuvent être de différents types.

my @animaux = 'chameau','lama','hibou';
say @animaux;

De nombreuses opérations peuvent être effectuées sur les tableaux comme le montre l'exemple suivant :

my @animaux = 'chameau','vigogne','lama';
say "Le zoo contient " ~ @animaux.elems ~ " animaux";
say "Les animaux sont: " ~ @animaux;
say "Je vais adopter un hibou pour le zoo";
@animaux.push("hibou");
say "Maintenant, mon zoo contient: " ~ @animaux;
say "Le premier animal que nous avons adopté est le " ~ @animaux[0];
@animaux.pop;
say "Malheureusement, le hibou est parti, il ne nous reste que: " ~ @animaux;
say "Nous allons fermer le zoo et laisser un animal seulement";
say "Nous allons faire partir: " ~ @animaux.splice(1,2) ~ " et laisser le " ~ @animaux;

Le zoo contient 3 animaux
Les animaux sont: chameau vigogne lama
Je vais adopter un hibou pour le zoo
Maintenant, mon zoo contient: chameau vigogne lama hibou
Le premier animal que nous avons adopté est le chameau
Malheureusement, le hibou est parti, il ne nous reste que: chameau vigogne lama
Nous allons fermer le zoo et laisser un animal seulement
Nous allons faire partir: vigogne lama et laisser le chameau

Explication

.elems retourne le nombre d'éléments contenus dans le tableau.
.push() ajoute un élément au tableau.
Nous pouvons accéder à un élément spécifique dans le tableau en spécifiant sa position @animaux[0].
.pop supprime le dernier élément du tableau.
.splice(a,b) supprime les b éléments à partir de la position a.

3-2-1. Tableaux de taille fixe▲

my @tableau;

my @tableau[3];

my @tableau[3];
@tableau[0] = "première valeur";
@tableau[1] = "deuxième valeur";
@tableau[2] = "troisième valeur";

my @tableau[3];
@tableau[0] = "première valeur";
@tableau[1] = "deuxième valeur";
@tableau[2] = "troisième valeur";
@tableau[3] = "quatrième valeur";

Index 3 for dimension 1 out of range (must be 0..2)

3-2-2. Tableaux à plusieurs dimensions▲

my @multi-tab[3;2];

my @multi-tab[3;2];
@multi-tab[0;0] = 1;
@multi-tab[0;1] = "x";
@multi-tab[1;0] = 2;
@multi-tab[1;1] = "y";
@multi-tab[2;0] = 3;
@multi-tab[2;1] = "z";
say @multi-tab

Un hachage (table de hachage/hash) est un ensemble de paires clef/valeur.

my %capitales = ('Angleterre','Londres','France','Paris');
say %capitales;

Une autre façon succincte de remplir le hachage :

my %capitales = (Angleterre => 'Londres', France => 'Paris');
say %capitales;

Voici quelques-unes des méthodes qui peuvent être appelées sur les hachages :

my %capitales = (Angleterre => 'Londres', Allemagne => 'Berlin');
%capitales.push: (France => 'Paris');
say %capitales;
say %capitales.kv;
say %capitales.keys;
say %capitales.values;
say "La capitale de la France est: " ~ %capitales<France>;

{Allemagne => Berlin, Angleterre => Londres, France => Paris}
(France Paris Allemagne Berlin Angleterre Londres)
(France Allemagne Angleterre)
(Paris Berlin Londres)
La capitale de la France est: Paris

Explication

.push: (clef => 'valeur') ajoute une nouvelle paire clef/valeur.

.kv renvoie la liste contenant toutes les clefs et valeurs.

.keys renvoie une liste des clefs.

.values renvoie une liste des valeurs.
On peut accéder à la valeur particulière d'un hachage en spécifiant sa clef, comme suit : %hachage<clef>

Dans les exemples précédents, on n'a pas précisé quel type de valeurs les variables peuvent contenir.

my $var = 'Texte';
say $var;
say $var.WHAT;

$var = 123;
say $var;
say $var.WHAT;

Comme vous pouvez le voir dans l'exemple ci-dessus, le type de valeur contenu dans $var était (Str) et puis (Int).

Ce style de programmation est appelé le typage dynamique. Dynamique dans le sens que les variables peuvent contenir des valeurs de tout type.

Maintenant, essayez d'exécuter l'exemple ci-dessous :
Remarquez Int avant le nom de la variable.

my Int $var = 'Texte';
say $var;
say $var.WHAT;

Il va échouer et retourner ce message d'erreur: Type check failed in assignment to $var; expected Int but got Str.

Ce qui est arrivé est que nous avons précisé au préalable que la variable doit être de type (Int). Quand nous avons essayé de lui affecter un (Str), le programme a échoué.

Ce style de programmation est appelé le typage statique. Statique dans le sens que les types de variables sont définis avant l'affectation et ne peuvent pas changer.

Perl 6 possède un typage graduel, les deux typages, statique et dynamique, peuvent être utilisés.

Voici une liste des types les plus couramment utilisés.

Les deux premiers ne seront probablement jamais utilisés, mais ils sont répertoriés à titre informatif.

L'introspection est le processus d'obtention d'informations sur les propriétés d'un objet comme son type.
Dans l'exemple précédent, nous avons utilisé .WHAT pour connaître le type de la variable.

my Int $var;
say $var.WHAT;    # (Int)
my $var2;
say $var2.WHAT;   # (Any)
$var2 = 1;
say $var2.WHAT;   # (Int)
$var2 = "Hello";
say $var2.WHAT;   # (Str)
$var2 = True;
say $var2.WHAT;   # (Bool)
$var2 = Nil;
say $var2.WHAT;   # (Any)

Le type d'une variable contenant une valeur est corrélé à sa valeur.
Le type d'une variable vide fortement déclarée est le type avec lequel elle a été déclarée.
Le type d'une variable vide qui n'a pas été déclarée fortement est (Any).
Pour vider la valeur d'une variable, vous pouvez lui affecter Nil.

3-5-1. Portée▲

my $var=1;

{
  my Str $var = 'Texte';
  say $var; #accessible
}
say $var; #inaccessible, renvoie une erreur

{
  my Str $var = 'Texte';
  say $var;
}
my Int $var = 123;
say $var;

Nous avons vu dans les exemples précédents comment affecter des valeurs aux variables.
L'affectation est faite en utilisant l'opérateur =

my Int $var = 123;
say $var;

Nous pouvons modifier la valeur attribuée à une variable :

Affecter

my Int $var = 123;
say $var;
$var = 999;
say $var;

123
999

D'autre part, nous ne pouvons pas changer la valeur liée à une variable.
Le lien est établi en utilisant l'opérateur :=

Lier

my Int $var := 123;
say $var;
$var = 999;
say $var;

123
Cannot assign to an immutable value

Une variable peut être également liée à une autre :

my $a;
my $b := $a;
$a = 7;
say $b;

Un lien ne peut être créé que lors de l'initialisation de la variable liée, et ne peut plus être modifié ensuite. Mais la valeur de la variable liée peut néanmoins changer si la valeur de la variable « maîtresse » à laquelle elle est liée change.

Le code ne s'exécute que si la condition a été remplie.

my $âge = 19;

if $âge > 18 {
  say 'Bienvenue'
}

En Perl 6, nous pouvons inverser le code et la condition.
Même si le code et la condition ont été inversés, la condition est toujours évaluée en premier.

my $âge = 19;

say 'Bienvenue' if $âge > 18;

Si la condition n'est pas remplie, nous pouvons toujours préciser des blocs d'exécution alternatifs en utilisant :

• else
• elsif

#exécuter le même code pour différentes valeurs de la variable
my $nombre-de-places = 9;

if $nombre-de-places <= 5 {
  say 'Je suis une berline'
} elsif $nombre-de-places <= 7 {
  say 'Je suis un monospace'
} else {
  say 'Je suis un van'
}

La version négative d'un if peut être écrite en utilisant unless.

Le code suivant :

my $chaussures-propres = False;

if not $chaussures-propres {
  say 'Nettoyez vos chaussures'
}

peut aussi être écrit ainsi :

my $chaussures-propres = False;

unless $chaussures-propres {
  say 'Nettoyez vos chaussures'
}

La négation en Perl 6 est faite en utilisant ! ou not.

unless (condition) est utilisé à la place de if not (condition).

unless ne peut pas avoir une clause else.

with fonctionne comme if, mais vérifie si la variable est définie.

my Int $var=1;

with $var {
  say 'Bonjour'
}

Si vous exécutez le code sans attribuer une valeur à la variable, il ne se passera rien.

my Int $var;

with $var {
  say 'Bonjour'
}

without est la version négative de with. Vous devriez être capable de relier le concept à unless.

Si la première condition with n'est pas remplie, un autre chemin peut être spécifié en utilisant orwith.
with et orwith peuvent être comparés à if et elsif.

La boucle for itère sur plusieurs valeurs.

my @tableau = 1,2,3;

for @tableau -> $element {
  say $element*100
}

Notez que nous avons créé une variable d'itération $element afin d'effectuer l'opération *100 sur chaque élément du tableau. Dans ce genre de construction, la variable d'itération $element est autodéclarée et ne doit donc pas être précédée par le déclarateur my.

given est l'équivalent Perl 6 de l'instruction switch dans d'autres langages.

my $var = 42;

given $var {
    when 0..50 { say 'Plus petit que 50'}
    when Int { say "est un Int" }
    when 42  { say 42 }
    default  { say "heu?" }
}

Si l'une des conditions est satisfaite, le processus d'appariement s'arrête (les autres conditions ne seront pas testées). Le code ci-dessus n'affichera donc que « Plus petit que 50 ».

Si l'on préfère tester aussi les conditions suivantes, proceed instruira Perl 6 à poursuivre l'appariement, même après un appariement réussi.

my $var = 42;

given $var {
    when 0..50 { say 'Plus petit que 50';proceed}
    when Int { say "est un Int";proceed}
    when 42  { say 42 }
    default  { say "huh?" }
}

loop est une autre façon d'écrire une boucle for.

En fait loop s'écrit comme le sont les boucles for dans les langages de programmation appartenant à la famille C.

Perl 6 appartient à la famille C.

loop (my $i=0; $i < 5; $i++) {
    say "Le nombre actuel est $i"
}

6-1-1. say▲

say 'Bonjour Madame.';
say 'Bonjour Monsieur.';

6-1-2. print▲

my $nom;

say "Salut quel est ton nom?";
$nom=get;

say "Cher $nom bienvenue à Perl 6";

6-1-3. prompt▲

my $nom = prompt("Salut quel est ton nom? ");

say "Cher $nom bienvenue à Perl 6";

Deux routines peuvent être utilisées pour exécuter des commandes shell :

• run : exécute une commande externe sans impliquer le shell ;
• shell : exécute une commande via le shell. Tous les métacaractères sont interprétés par le shell, y compris les tubes (pipes), les redirections, les variables d'environnement, etc.

Voici un exemple sous Linux, Unix ou OS X :

my $nom = 'Neo';
run 'echo', "salut $nom";
shell "ls";

Et un exemple sous Windows :

shell "dir";

echo et ls sont des mots-clefs communs des shells Unix ou Linux.
echo imprime le texte sur le terminal (l'équivalent de say en Perl 6).
ls liste tous les fichiers et dossiers dans le répertoire courant sous Linux et dir fait la même chose sous Windows.

6-3-1. slurp▲

John 9
Johnnie 7
Jane 8
Joanna 7

my $data = slurp "datafile.txt";
say $data;

6-3-2. spurt▲

my $newdata = "New scores:
Paul 10
Paulie 9
Paulo 11";

spurt "newdatafile.txt", $newdata;

Perl 6 peut lister le contenu d'un répertoire sans exécuter des commandes shell (en utilisant ls) comme nous l'avons vu dans un exemple précédent.

say dir;              #Liste les fichiers et dossiers dans le répertoire courant
say dir "Documents"; #Liste les fichiers et dossiers dans le répertoire spécifié
my @répertoire = dir; # Récupère les fichiers dans un tableau

De plus, vous pouvez créer de nouveaux dossiers et les supprimer.

mkdir "newfolder";
rmdir "newfolder";

mkdir crée un nouveau répertoire.
rmdir supprime un répertoire vide. Renvoie une erreur s'il n'est pas vide.

Vous pouvez également vérifier si le chemin d'accès spécifié existe, si c'est un fichier ou un répertoire.

Dans le répertoire où vous allez exécuter le script ci-dessous, créez un dossier vide folder123 et un fichier Perl 6 vide script123.pl6

say "script123.pl6".IO.e;
say "folder123".IO.e;

say "script123.pl6".IO.d;
say "folder123".IO.d;

say "script123.pl6".IO.f;
say "folder123".IO.f;

IO.e vérifie si le répertoire/fichier existe.
IO.f vérifie si c'est un fichier.
IO.d vérifie si c'est un dossier.

Les routines ou subroutines ou subs sont un moyen de conditionnement d'un ensemble de fonctionnalités.

Une routine est définie avec le mot-clef sub. Après leur définition, elles peuvent être appelées par leur nom.
Examinez l'exemple ci-dessous :

sub salut-alien {
  say "Bonjour Terriens";
}

salut-alien;

L'exemple précédent présente une routine qui ne nécessite aucun argument.

Beaucoup de routines requièrent des données en entrée pour fonctionner. Ces données sont fournies par des arguments.
La signature est le nombre et le type d'arguments que la routine accepte.

La routine ci-dessous accepte une chaîne de caractères pour argument :

sub dis-bonjour (Str $nom) {
    say "Bonjour " ~ $nom ~ "!!!!"
}
dis-bonjour "Paul";
dis-bonjour "Paula";

Il est possible de définir plusieurs routines ayant le même nom, mais des signatures différentes. Lorsque la routine est appelée, l'environnement d'exécution décidera quelle version utiliser en fonction du nombre et du type des arguments fournis. Ce type de routines est défini de la même manière que les routines normales sauf que nous utilisons le mot-clef multi à la place de sub.

multi salut($nom) {
    say "Bonne Journée $nom";
}
multi salut($nom, $titre) {
    say "Bonne Journée $titre $nom";
}

salut "Gaspard";
salut "Josiane","Mme.";

Si une routine est définie comme acceptant un argument, et nous l'appelons sans fournir l'argument requis, la routine va échouer.

Cependant, Perl 6 nous offre la possibilité de définir des routines avec des :

• arguments optionnels ;
• arguments par défaut.

Les arguments optionnels sont définis en ajoutant ? après le nom de l'argument.

sub dis-bonjour($nom?) {
  with $nom { say "Bonjour " ~ $nom }
  else { say "Bonjour être humain" }
}
dis-bonjour;
dis-bonjour("Laura");

Si l'utilisateur ne fournit pas un argument, la routine peut fournir une valeur par défaut.
Cela se fait par l'attribution d'une valeur à l'argument durant la définition de la routine.

sub dis-bonjour($nom="Raoul") {
  say "Bonjour " ~ $nom;
}
dis-bonjour;
dis-bonjour("Laura");

Les fonctions/routines sont des entités de première classe :

• elles peuvent être passées comme un argument ;
• elles peuvent être renvoyées par une fonction ;
• on peut les affecter à une variable.

Un bon exemple pour vérifier ce concept est la fonction map.
map est une fonction d'ordre supérieur, elle accepte une autre fonction comme argument.

my @tableau = <1 2 3 4 5>;
sub carré($x) {
  $x ** 2
}
say map(&carré,@tableau);

(1 4 9 16 25)

Explication 

Nous avons défini une routine appelée carré, qui met à la puissance 2 l'argument qui lui est passé.
Ensuite, nous avons utilisé map, une fonction d'ordre supérieur en lui passant deux arguments, une routine et un tableau.
Le résultat est une liste de tous les éléments du tableau mis à la puissance 2.

Notez que quand une routine est passée comme argument, nous la préfixons avec &.

Tous les objets code en Perl 6 sont des fermetures, ce qui implique qu'ils peuvent référencer des variables lexicales d'une portée externe.

Une fonction anonyme est également appelée lambda.
Une fonction anonyme n'est pas liée à un identifiant (elle n'a pas de nom).

Réécrivons l'exemple de map avec une fonction anonyme

my @tableau = <1 2 3 4 5>;
say map(-> $x {$x ** 2},@tableau);

Notez qu'au lieu de définir une routine et de la passer en argument à map, nous la définissons directement à l'intérieur de map.
La routine anonyme -> $x {$x ** 2} n'a pas de nom et ne peut donc pas être appelée.

En dialecte Perl 6, nous l'appelons un bloc pointu (pointy block).

Un bloc pointu peut aussi être utilisé pour assigner des fonctions à des variables :

my $carré = -> $x {
  $x ** 2
}
say $carré(9);

En Perl 6, les méthodes peuvent être enchaînées, vous n'avez plus à passer le résultat d'une méthode comme argument à une autre.

Supposons qu'on vous donne un tableau de valeurs. On vous demande de retourner les valeurs uniques de ce tableau en ordre décroissant.

Vous pouvez résoudre ce problème en écrivant quelque chose comme ceci :

my @tableau = <7 8 9 0 1 2 4 3 5 6 7 8 9>;
my @tableau-final = reverse(sort(unique(@tableau)));
say @tableau-final;

Nous appelons d'abord la fonction unique sur @tableau puis nous passons le résultat comme argument à sort et ensuite passons le résultat à reverse.

L'exemple ci-dessus peut aussi être écrit comme suit, en prenant avantage de l'enchaînement des méthodes :

my @tableau = <7 8 9 0 1 2 4 3 5 6 7 8 9>;
my @tableau-final = @tableau.unique.sort.reverse;
say @tableau-final;

Vous pouvez constater qu'enchaîner les méthodes est plus agréable à l'œil et au cerveau.

L'opérateur feed, appelé Pipe dans d'autres langages fonctionnels, donne une meilleure vue de l'enchaînement de méthodes.

Feed vers l'avant

my @tableau = <7 8 9 0 1 2 4 3 5 6 7 8 9>;
@tableau ==> unique()
         ==> sort()
         ==> reverse()
         ==> my @tableau-final;
say @tableau-final;

Explication

commence avec `@tableau` puis renvoie la liste des éléments uniques
                         puis effectue un tri
                         puis l'inverse
                         puis stocke le résultat dans @tableau-final

Comme vous le voyez, le flux des appels de méthodes se fait de haut en bas.

Feed vers l'arrière

my @tableau = <7 8 9 0 1 2 4 3 5 6 7 8 9>;
my @tableau-final-v2 <== reverse()
                     <== sort()
                     <== unique()
                     <== @tableau;
say @tableau-final-v2;

Explication

Le feed vers l'arrière est comme celui vers l'avant, mais se fait à rebours.
Le flux des appels de méthodes se fait de bas en haut.

L'hyperpérateur >>. invoque une méthode sur tous les éléments d'une liste et renvoie une liste des résultats.

my @tableau = <0 1 2 3 4 5 6 7 8 9 10>;
sub est-pair($var) { $var %% 2 };

say @tableau>>.is-prime;
say @tableau>>.&est-pair;

En utilisant l'hyperopérateur, nous pouvons appeler des méthodes déjà définies dans Perl 6, par exemple is-prime qui nous indique si un nombre est premier ou pas.
Nous pouvons également définir de nouvelles routines et les appeler en utilisant l'hyperopérateur. En ce cas, il faut préfixer la méthode avec &. Ex. : &est-pair.

Cette façon de faire est très pratique, car elle nous évite d'écrire une boucle for d'itération sur chaque valeur.

Une jonction est une superposition logique des valeurs.

Dans l'exemple ci-dessous, 1|2|3 est une jonction.

my $var = 2;
if $var == 1|2|3 {
  say "La variable est soit 1 ou 2 ou 3";
}

L'utilisation de jonctions déclenche généralement l'autothreading ; l'opération est effectuée pour chaque élément de la jonction, les résultats sont combinés en une seule jonction et renvoyés.

Une liste paresseuse est une liste dont l'évaluation peut être retardée.
L'évaluation paresseuse diffère l'évaluation d'une expression jusqu'au moment où celle-ci est nécessaire, et évite ainsi la répétition des évaluations en stockant les résultats dans une table de correspondance.

Les avantages, parmi d'autres, sont les suivants :

• un gain de performance évitant les calculs inutiles ;
• la possibilité de construire des structures de données potentiellement infinies ;
• la possibilité de définir une structure de contrôle.

Pour construire une liste paresseuse, on utilise l'opérateur infixé ...
Une liste paresseuse possède un ou des éléments initiaux, un générateur, et un élément final.

Liste paresseuse simple

my $lazylist = (1 ... 10);
say $lazylist;

L'élément initial est 1, et l'élément final est 10. Aucun générateur n'a été défini donc le générateur par défaut se fait par succession (+1).
Autrement dit, cette liste paresseuse retournera (à la demande) les éléments suivants : (1, 2, 3, 4, 5, 6, 7, 8, 9, 10).

Liste paresseuse infinie

my $lazylist = (1 ... Inf);
say $lazylist;

Cette liste retournera (à la demande) les entiers entre 1 et l'infini, c'est-à-dire tous les entiers.

Liste paresseuse utilisant un générateur déduit

my $lazylist = (0,2 ... 10);
say $lazylist;

Les éléments initiaux sont 0 et 2, et l'élément final est 10. Aucun générateur n'est défini, mais en utilisant les éléments initiaux, Perl 6 déduira que le générateur est (+2).
Cette liste paresseuse retournera (à la demande) les éléments suivants : (0, 2, 4, 6, 8, 10).

Liste paresseuse utilisant un générateur défini

my $lazylist = (0, { $_ + 3 } ... 12);
say $lazylist;

Dans cet exemple, nous définissons explicitement un générateur mis entre { }
Cette liste paresseuse retournera (à la demande ) les éléments suivants : (0, 3, 6, 9, 12).

my $lazylist = (0, { $_ + 3 } ... 10);
say $lazylist;

my $lazylist = (0, { $_ + 3 } ...^ * > 10);
say $lazylist;

La Programmation Orientée Objet est l'un des paradigmes les plus utilisés de nos jours.
Un objet est une collection de variables et de routines empaquetées ensemble.
Les variables sont appelées des attributs et les routines des méthodes.
Les attributs définissent l'état et les méthodes le comportement d'un objet.

Une classe définit la structure d'une collection d'objets.

Pour comprendre cette relation, examinez l'exemple ci-dessous :

Dans le jargon orienté objet, nous disons que les objets sont des instances d'une classe.

Voyez le script ci-dessous :

class Humain {
  has $nom;
  has $age;
  has $sexe;
  has $nationalité;
}

my $françois;
$françois = Humain.new(nom => 'François', age => 23, sexe => 'M', nationalité => 'Sarthoise');
say $françois;

Le mot-clef class est utilisé pour définir une classe.
Le mot-clef has est utilisé pour définir un attribut d'une classe.
La méthode .new() est appelée un constructeur. Elle crée l'objet comme une instance de la classe sur laquelle elle a été appelée.

Dans le script ci-dessus, la nouvelle variable $françois contient une référence vers une nouvelle instance de « Humain » définie par Humain.new().
Les arguments passés à la méthode .new() sont utilisés pour initialiser les attributs de l'objet.

Une classe peut se voir donner une portée lexicale en utilisant my :

my class Humain {

}

L'encapsulation est un concept orienté objet qui rassemble une collection de données et de méthodes.
Les données (attributs) dans un objet se doivent d'être privées, c'est-à-dire qu'elles ne sont accessibles qu'à l'intérieur de l'objet.
Pour avoir accès aux attributs depuis l'extérieur de l'objet, on utilise des méthodes appelées accesseurs.

Les deux scripts ci-dessous ont le même résultat.

Accès direct à la variable :

my $var = 7;
say $var;

Encapsulation :

my $var = 7;
sub disvar {
  $var;
}
say disvar;

La méthode disvar est un accesseur. Elle nous permet d'avoir accès à la valeur de la variable sans avoir d'accès direct à celle-ci.

L'encapsulation est facilitée en Perl 6 par l'emploi de twigils.
Les twigils sont des sigils secondaires. Ils s'intercalent entre le sigil et le nom de l'attribut.
On utilise 2 twigils dans les classes :

• ! est utilisé pour déclarer explicitement qu'un attribut est privé ;
• . est utilisé pour générer automatiquement un accesseur pour un attribut.

Par défaut, tous les attributs sont privés, mais c'est une saine habitude que d'utiliser le twigil !.

En accord avec ce qui vient d'être dit, nous devrions réécrire la classe comme suit :

class Humain {
  has $!nom;
  has $!age;
  has $!sexe;
  has $!nationalité;
}

my $françois = Humain.new(nom => 'François', age => 23, sexe => 'M', nationalité => 'Sarthoise');
say $françois;

Si vous ajoutez à ce script la ligne suivante : say $françois.age;
L'erreur suivante sera retournée : Method 'age' not found for invocant of class 'Humain'
La raison en est que $!age est privé et ne peut être utilisé que dans l'objet. Y accéder en dehors de l'objet retournera une erreur.

Maintenant remplacez has $!age par has $.age et voyez quel est le résultat de say $françois.age;

En Perl 6, toutes les classes héritent d'un constructeur par défaut .new().
Il peut être utilisé pour créer des objets en leur fournissant des arguments.
Le constructeur par défaut ne peut se voir fournir que des arguments nommés.
Si vous regardez l'exemple ci-dessus, vous voyez que les arguments passés à .new() sont définis par leur noms :

• nom ⇒ 'François'
• age ⇒ 23

Et si je ne veux pas passer le nom de chaque attribut à chaque fois que je crée un nouvel objet ?
Je dois alors créer un autre constructeur qui accepte les arguments positionnels.

class Humain {
  has $.nom;
  has $.age;
  has $.sexe;
  has $.nationalité;
  #nouveau constructeur qui prime sur constructeur par défaut.
  method new ($nom,$age,$sexe,$nationalité) {
    self.bless(:$nom,:$age,:$sexe,:$nationalité);
  }
}

my $françois = Humain.new('François',23,'M','Sarthoise');
say $françois;

Le constructeur qui accepte des arguments positionnels doit être défini comme ci-dessus.

9-4-1. Introduction▲

class Humain {
  has $.nom;
  has $.age;
  has $.sexe;
  has $.nationalité;
  has $.éligible;
  method confirme-éligibilité {
      if self.age < 21 {
        $!éligible = 'Non'
      } else {
        $!éligible = 'Oui'
      }
  }

}

my $françois = Humain.new(nom => 'John', age => 23, sexe => 'M', nationalité => 'Sarthoise');
$françois.confirme-éligibilité;
say $françois.éligible;

9-4-2. Méthodes privées▲

method !jesuisprivée {
  #du code ici
}

method jesuispublique {
  self!jesuisprivée;
  #faire d'autres choses
}

Les attributs de classe sont des attributs qui appartiennent à la classe, mais pas à ses objets.
Ils peuvent être initialisés pendant la définition.
Les attributs de classe sont déclarés en utilisant my au lieu de has.
Ils sont appelés sur la classe elle-même au lieu de ses objets.

class Humain {
  has $.nom;
  my $.compteur = 0;
  method new($nom) {
    Humain.compteur++;
    self.bless(:$nom);
  }
}
my $a = Humain.new('a');
my $b = Humain.new('b');

say Humain.compteur;

Jusqu'à présent, tous les exemples que nous avons vus utilisent des accesseurs pour obtenir des informations sur les attributs de l'objet.

Et si nous avons besoin de modifier la valeur d'un attribut, nous devons marquer cet attribut comme lisible/modifiable en utilisant le mot-clef is rw

class Humain {
  has $.nom;
  has $.age is rw;
}
my $françois = Humain.new(nom => 'François', age => 21);
say $françois.age;

$françois.age = 23;
say $françois.age;

Par défaut, tous les attributs sont déclarés en lecture seule, mais vous pouvez aussi les déclarer explicitement avec is readonly.

9-7-1. Introduction▲

class Humain {
  has $.nom;
  has $.age;
}

class Employé {
  has $.nom;
  has $.age;
  has $.société;
  has $.salaire;
}

class Humain {
  has $.nom;
  has $.age;
}

class Employé is Humain {
  has $.société;
  has $.salaire;
}

9-7-2. Surcharge▲

class Humain {
  has $.nom;
  has $.age;
  method présentez-vous {
    say "Bonjour je suis un être humain, et je m'appelle " ~ self.nom;
  }
}

class Employé is Humain {
  has $.société;
  has $.salaire;
}

my $françois = Humain.new(nom => 'François', age => 23,);
my $anne = Employé.new(nom => 'Anne', age => 25, société => 'Acme', salaire => 2000);

$françois.présentez-vous;
$anne.présentez-vous;

class Humain {
  has $.nom;
  has $.age;
  method présentez-vous {
    say "Bonjour je suis un être humain, et je m'appelle " ~ self.nom;
  }
}

class Employé is Humain {
  has $.société;
  has $.salaire;
  method présentez-vous {
    say "Bonjour je suis un être humain, et je m'appelle " ~ self.nom ~ ' et je travaille chez: ' ~ self.société;
  }

}

my $françois = Humain.new(nom => 'François', age => 23,);
my $anne = Employé.new(nom => 'Anne', age => 25, société => 'Acme', salaire => 2000);

$françois.présentez-vous;
$anne.présentez-vous;

9-7-3. Sous-méthodes▲

L'héritage multiple est disponible en Perl 6. Une classe peut hériter de plusieurs autres classes.

class barre-graph {
  has Int @.barre-valeurs;
  method dessiner {
    say @.barre-valeurs;
  }
}

class ligne-graph {
  has Int @.ligne-valeurs;
  method dessiner {
    say @.ligne-valeurs;
  }
}

class combo-graph is barre-graph is ligne-graph {
}

my $ventes-réelles = barre-graph.new(barre-valeurs => [10,9,11,8,7,10]);
my $ventes-prévisions = ligne-graph.new(ligne-valeurs => [9,8,10,7,6,9]);

my $réelles-vs-prévisions = combo-graph.new(barre-valeurs => [10,9,11,8,7,10],
                                            ligne-valeurs => [9,8,10,7,6,9]);
say "Ventes Réelles:";
$ventes-réelles.dessiner;
say "Ventes Prévisionelles:";
$ventes-prévisions.dessiner;
say "Réelles vs Prévisionelles:";
$réelles-vs-prévisions.dessiner;

Ventes Réelles:
[10 9 11 8 7 10]
Ventes Prévisionelles:
[9 8 10 7 6 9]
Réelles vs Prévisionelles:
[10 9 11 8 7 10]

Explication

La classe combo-graph doit être capable de contenir deux séries, une pour les valeurs réelles dessinées sous forme de barres et une autre pour les valeurs prévisionnelles dessinées sous forme de ligne.
C'est pourquoi nous l'avons définie comme fille de ligne-graph et barre-graph.
Vous avez remarqué que l'appel de la méthode dessiner sur combo-graph n'a pas rendu les bons résultats.

Une seule série a été dessinée.
Que s'est-il passé ?
combo-graph hérite de barre-graph et de ligne-graph ; et chaque parent possède une méthode appelée dessiner. Quand nous appelons cette méthode sur combo-graph, Perl 6 résoudra le conflit en appelant une des méthodes héritées.

Correction

Pour avoir un comportement valide, nous devons surcharger la méthode dessiner dans combo-graph.

class barre-graph {
  has Int @.barre-valeurs;
  method dessiner {
    say @.barre-valeurs;
  }
}

class ligne-graph {
  has Int @.ligne-valeurs;
  method dessiner {
    say @.ligne-valeurs;
  }
}

class combo-graph is barre-graph is ligne-graph {
  method dessiner {
    say @.barre-valeurs;
    say @.ligne-valeurs;
  }
}

my $ventes-réelles = barre-graph.new(barre-valeurs => [10,9,11,8,7,10]);
my $ventes-prévisions = ligne-graph.new(ligne-valeurs => [9,8,10,7,6,9]);

my $réelles-vs-prévisions = combo-graph.new(barre-valeurs => [10,9,11,8,7,10],
                                            ligne-valeurs => [9,8,10,7,6,9]);
say "Ventes Réelles:";
$ventes-réelles.dessiner;
say "Ventes Prévisionelles:";
$ventes-prévisions.dessiner;
say "Réelles vs Prévisionelles:";
$réelles-vs-prévisions.dessiner;

Ventes Réelles:
[10 9 11 8 7 10]
Ventes Prévisionelles:
[9 8 10 7 6 9]
Réelles vs Prévisionelles:
[10 9 11 8 7 10]
[9 8 10 7 6 9]

Les rôles sont assimilables à des classes, dans le sens qu'ils sont une collection d'attributs et de méthodes.

Les rôles sont déclarés avec le mot-clef role, les classes qui veulent implémenter un rôle peuvent le faire en utilisant le mot-clef does.

Réécrivons l'exemple d'héritage multiple en utilisant des rôles :

role barre-graph {
  has Int @.barre-valeurs;
  method dessiner {
    say @.barre-valeurs;
  }
}

role ligne-graph {
  has Int @.ligne-valeurs;
  method dessiner {
    say @.ligne-valeurs;
  }
}

class combo-graph does barre-graph does ligne-graph {
  method dessiner {
    say @.barre-valeurs;
    say @.ligne-valeurs;
  }
}

my $ventes-réelles = barre-graph.new(barre-valeurs => [10,9,11,8,7,10]);
my $ventes-prévisions = ligne-graph.new(ligne-valeurs => [9,8,10,7,6,9]);

my $réelles-vs-prévisions = combo-graph.new(barre-valeurs => [10,9,11,8,7,10],
                                            ligne-valeurs => [9,8,10,7,6,9]);
say "Ventes Réelles:";
$ventes-réelles.dessiner;
say "Ventes Prévisionelles:";
$ventes-prévisions.dessiner;
say "Réelles vs Prévisionelles:";
$réelles-vs-prévisions.dessiner;

Si vous lancez le script ci-dessus, vous constatez que les résultats sont les mêmes.

Vous vous demandez maintenant : si les rôles se comportent comme des classes, quelle est leur utilité ?
Pour répondre à votre question, modifiez le premier script utilisé pour illustrer l'héritage multiple, celui où nous avons oublié de surclasser la méthode dessiner.

role barre-graph {
  has Int @.barre-valeurs;
  method dessiner {
    say @.barre-valeurs;
  }
}

role ligne-graph {
  has Int @.ligne-valeurs;
  method dessiner {
    say @.ligne-valeurs;
  }
}

class combo-graph does barre-graph does ligne-graph {
}

my $ventes-réelles = barre-graph.new(barre-valeurs => [10,9,11,8,7,10]);
my $ventes-prévisions = ligne-graph.new(ligne-valeurs => [9,8,10,7,6,9]);

my $réelles-vs-prévisions = combo-graph.new(barre-valeurs => [10,9,11,8,7,10],
                                            ligne-valeurs => [9,8,10,7,6,9]);
say "Ventes Réelles:";
$ventes-réelles.dessiner;
say "Ventes Prévisionelles:";
$ventes-prévisions.dessiner;
say "Réelles vs Prévisionelles:";
$réelles-vs-prévisions.dessiner;

===SORRY!===
Method 'dessiner' must be resolved by class combo-graph because it exists in multiple roles (ligne-graph, barre-graph)

Explication

Si plusieurs rôles sont appliqués à la même classe, et un conflit survient, une erreur de compilation sera lancée.
Ceci est une approche plus sûre que l'héritage multiple, où les conflits ne sont pas pris comme des erreurs et sont résolus à l'exécution.

Les rôles vous avertiront en cas de conflit.

L'introspection sert à obtenir des informations sur les propriétés d'un objet : comme son type, ses attributs ou ses méthodes.

class Humain {
  has $.nom;
  has $.age;
  method présentez-vous {
    say "Bonjour je suis un être humain, et je m'appelle " ~ self.nom;
  }
}

class Employé is Humain {
  has $.société;
  has $.salaire;
}

my $françois = Humain.new(nom => 'François', age => 23,);
my $anne = Employé.new(nom => 'Anne', age => 25, société => 'Acme', salaire => 2000);

$françois.présentez-vous;
$anne.présentez-vous;

say $françois.WHAT;
say $anne.WHAT;
say $françois.^attributes;
say $anne.^attributes;
say $françois.^methods;
say $anne.^methods;
say $anne.^parents;
if $anne ~~ Humain {say 'anne est un être humain'};

L'introspection est facilitée par :

• .WHAT renvoie la classe depuis laquelle l'objet a été créé ;
• .^attributes renvoie une liste qui contient tous les attributs de l'objet ;
• .^methods renvoie toutes les méthodes invocables de l'objet ;
• .^parents renvoie toutes les classes parentes de la classe à laquelle appartient l'objet ;
• ~~ est appelé l'opérateur de correspondance intelligente (smart-match). Il renvoie Vrai si l'objet correspond à sa classe de création ou à une de celles dont elle a hérité.

Les exceptions sont un comportement particulier qui intervient quand quelque chose se passe mal à l'exécution.
On dit que les exceptions sont lancées ou générées.

Le script ci-dessous s'exécute correctement :

my Str $nom;
$nom = "Josiane";
say "Bonjour " ~ $nom;
say "Comment ça va?"

Bonjour Josiane
Comment ça va?

Maintenant, voici un script analogue qui lance une exception :

my Str $nom;
$nom = 123;
say "Bonjour " ~ $nom;
say "Comment ça va?"

Type check failed in assignment to $nom; expected Str but got Int (123)

Vous remarquerez que quand une erreur survient (ici affecter un nombre à une variable de chaîne), le programme s'arrête et les lignes suivantes ne seront pas évaluées, même si elles sont correctes.

La gestion des exceptions capture une exception qui a été lancée afin que le script puisse continuer à fonctionner.

my Str $nom;
try {
  $nom = 123;
  say "Hello " ~ $nom;
  CATCH {
    default {
      say "Pouvez vous nous redonner votre nom, nous ne l'avons pas trouvé dans le registre.";
    }
  }
}
say "Comment ça va?";

Pouvez vous nous redonner votre nom, nous ne l'avons pas trouvé dans le registre.
Comment ça va?

La gestion d'exception se fait en utilisant un bloc try-CATCH.

try {
  #le code va ici
  #si quelque chose se passe mal le script entre dans le bloc CATCH
  #si tout se passe bien, le bloc CATCH sera ignoré
  CATCH {
    default {
      #le code présent ici ne sera évalué que si une exception a été lancée
    }
  }
}

Un bloc CATCH peut se définir de la même façon qu'un bloc given. Ce qui implique qu'on puisse faire un catch sur différents types d'exceptions.

try {
  #le code va ici
  #si quelque chose se passe mal le script entre dans le bloc CATCH
  #si tout se passe bien, le bloc CATCH sera ignoré
  CATCH {
    when X::AdHoc { #faire quelque chose si une exception de type X::AdHoc est lancée }
    when X::IO { #faire quelque chose si une exception de type X::IO est lancée }
    when X::OS { #faire quelque chose si une exception de type X::OS est lancée }
    default { #faire quelque chose si une exception est lancée qui ne correspond pas aux types précédents }
  }
}

À l'inverse de capturer les exceptions, Perl 6 vous permet aussi d'en lancer.
On peut lancer deux types d'exceptions :

• les exceptions ad hoc ;
• les exceptions typées.

my Int $age = 21;
die "Erreur !";

my Int $age = 21;
X::AdHoc.new(payload => 'Erreur !').throw;

Les exceptions ad hoc sont lancées en utilisant la routine die suivie du message de l'exception.

Les exceptions typées sont des objets, d'où l'utilisation du constructeur .new() dans l'exemple ci-dessus.
Toutes les exceptions descendent de la classe X, quelques exemples ci-dessous :
X::AdHoc est le type le plus simple d'exception ;
X::IO est lié aux erreurs IO (entrées/sorties) ;
X::OS est lié aux erreurs OS (système) ;
X::Str::Numeric est lié aux erreurs de conversion d'une chaîne vers un nombre.

Une expression régulière peut être définie comme suit :

• /soleil/
• m/soleil/
• rx/soleil/

Les espaces, sauf si spécifiés comme requis explicitement, ne sont pas pris en compte : m/soleil/ and m/ soleil / sont identiques.

Les caractères alphanumériques et le tiret bas _ sont utilisés tels quels.
Tous les autres caractères doivent être « protégés » en les préfixant de la barre oblique inversée, ou mis entre guillemets (simples ou doubles).

if 'Température: 13' ~~ m/ \: / {
    say "La chaîne fournie contient le caractère deux-points :";
}

if 'Age = 13' ~~ m/ '=' / {
    say "La chaîne fournie contient le caractère égal = ";
}

if 'nom@société.com' ~~ m/ "@" / {
    say "Cette adresse mail semble valide car elle contient un caractère @";
}

Les caractères peuvent être réunis en catégories de reconnaissances. On peut également utiliser la négation d'une catégorie (tout sauf cette catégorie) :

if "Robert123" ~~ / \d / {
  say "Pas de comparaison valide car pas de chiffres";
} else {
  say "Comparaison valide, car un chiffre"
}
if "John-Doe" ~~ / \s / {
  say "Cette chaîne contient un espace";
} else {
  say "Cette chaîne ne contient pas d'espace"
}

11-3-1. Propriétés unicode▲

if "Robert123" ~~ / <:N> / {
  say "Contient un chiffre";
} else {
  say "Ne contient pas un chiffre"
}
if "Albert-Ebasque" ~~ / <:Lu> / {
  say "Contient une lettre en majuscule";
} else {
  say "Ne contient de lettre en majuscule"
}
if "Albert-Ebasque" ~~ / <:Pd> / {
  say "Contient un tiret";
} else {
  say "Ne contient pas un tiret"
}

11-3-2. Métacaractères▲

if 'abc' ~~ m/ a.c / {
    say "Correspondance";
}
if 'a2c' ~~ m/ a.c / {
    say "Correspondance";
}
if 'ac' ~~ m/ a.c / {
    say "Correspondance";
  } else {
    say "Pas de Correspondance";
}

11-3-3. Quantificateurs▲

if 'ac' ~~ m/ a?c / {
    say "Correspondance";
  } else {
    say "Pas de Correspondance";
}
if 'c' ~~ m/ a?c / {
    say "Correspondance";
  } else {
    say "Pas de Correspondance";
}

if 'az' ~~ m/ a*z / {
    say "Correspondance";
  } else {
    say "Pas de Correspondance";
}
if 'aaz' ~~ m/ a*z / {
    say "Correspondance";
  } else {
    say "Pas de Correspondance";
}
if 'aaaaaaaaaaz' ~~ m/ a*z / {
    say "Correspondance";
  } else {
    say "Pas de Correspondance";
}
if 'z' ~~ m/ a*z / {
    say "Correspondance";
  } else {
    say "Pas de Correspondance";
}

if 'az' ~~ m/ a+z / {
    say "Correspondance";
  } else {
    say "Pas de Correspondance";
}
if 'aaz' ~~ m/ a+z / {
    say "Correspondance";
  } else {
    say "Pas de Correspondance";
}
if 'aaaaaaaaaaz' ~~ m/ a+z / {
    say "Correspondance";
  } else {
    say "Pas de Correspondance";
}
if 'z' ~~ m/ a+z / {
    say "Correspondance";
  } else {
    say "Pas de Correspondance";
}

Quand la mise en correspondance avec une regex est positive, le résultat est stocké dans la variable spéciale $/

if 'Rakudo est un compilateur Perl 6' ~~ m/compilateur/ {
    say "La correspondance est: " ~ $/;
    say "La chaîne avant la correspondance est: " ~ $/.prematch;
    say "La chaîne après la correspondance est: " ~ $/.postmatch;
    say "La chaîne reconnue commence à la position: " ~ $/.from;
    say "La chaîne reconnue finit à la position: " ~ $/.to;
}

La correspondance est: compilateur
La chaîne avant la correspondance est: Rakudo est un 
La chaîne après la correspondance est:  Perl 6
La chaîne reconnue commence à la position: 14
La chaîne reconnue finit à la position: 25

Explication

$/ renvoie un Objet de Correspondance (Match Object), c'est-à-dire la chaîne qui correspond à la regex
Les méthodes suivantes peuvent être appelées sur le l'Objet de Correspondance :
.prematch renvoie la chaîne qui précède la correspondance ;
.postmatch renvoie la chaîne qui suit la correspondance ;
.from renvoie la position de départ de la correspondance ;
.to renvoie la position de fin de la correspondance.

Vérifions si une adresse mail est valide ou non.
Pour la pertinence de cet exemple, nous conviendrons qu'une adresse mail est valide si elle est formée comme suit :
prénom [point] nom [arobase] société [point] (com/org/net).

my $email = 'sam.suffit@perl6.org';
my $regex = / <:L>+\.<:L>+\@<:L+:N>+\.<:L>+ /;

if $email ~~ $regex {
  say $/ ~ " est une adresse mail valide";
} else {
  say "n'est pas une adresse mail valide";
}

sam.suffit@perl6.org est une adresse mail valide

Explication

<:L> correspond à une lettre.
<:L>+ correspond à une lettre ou plus.
\. correspond à un caractère [point].
\@ correspond à un caractère [arobase].
<:L+:N> correspond à une lettre ou un chiffre.
<:L+:N>+ correspond à une lettre ou un chiffre, plusieurs fois.

La regex peut être décomposée comme suit :

• nom <:L>+
• [point] \.
• prénom <:L>+
• [arobase] \@
• nom de la société <:L+:N>+
• [point] \.
• com/org/net <:L>+

D'une autre façon, une regex peut être divisée en plusieurs regex nommées :

my $email = 'sam.suffit@perl6.org';
my regex lettres { <:L>+ };
my regex point { \. };
my regex arobase { \@ };
my regex lettres-et-chiffres { <:L+:N>+ };

if $email ~~ / <lettres> <point> <lettres> <arobase> <lettres-et-chiffres> <point> <lettres> / {
  say $/ ~ " est une adresse mail valide";
} else {
  say "Ce n'est pas une adresse mail valide";
}

Une regex nommée est définie en utilisant la syntaxe suivante : my regex nom-de-la-regex {définition de la regex }
Une regex nommée peut être appelée en utilisant la syntaxe suivante : <nom-de-la-regex>

MD5 est une fonction de hachage cryptographique qui produit une valeur de hachage de 128 bits.
MD5 a de nombreuses utilités, dont le chiffrage des mots de passe stockés dans une base de données. Quand un nouvel utilisateur s'inscrit, ses références ne sont pas stockées en texte brut, mais sous forme de hachage. L'idée derrière tout ceci est que si la base de données est compromise, l'attaquant ne pourra pas identifier les mots de passe.

Disons que vous ayez besoin d'un script qui génère un hachage MD5 sur un mot de passe avant stockage dans la base de données.

Heureusement, Perl 6 possède un module qui implémente l'algorithme de hachage MD5. Installons-le :

panda install Digest::MD5

Maintenant, lançons le script suivant :

use Digest::MD5;
my $secret = "secret123";
my $secret-h = Digest::MD5.new.md5_hex($secret);

say $secret-h;

Pour lancer la fonction md5_hex() qui crée les hachages, nous devons charger le module voulu.
Le mot-clef use charge le module pour son utilisation dans le script.

Voyons comment nous pouvons générer des caractères en utilisant Unicode.

say "a";
say "\x0061";
say "\c[LATIN SMALL LETTER A]";

Les trois lignes ci-dessus montrent les différentes façons de construire un caractère :

1. Écriture directe (graphème) ;
2. Utilisation de \x suivi du point de code ;
3. Utilisation de \c et du nom du point de code.

Générons maintenant une émoticône (un smiley ).

say "☺";
say "\x263a";
say "\c[WHITE SMILING FACE]";

Un autre exemple en combinant deux points de code :

say "á";
say "\x00e1";
say "\x0061\x0301";
say "\c[LATIN SMALL LETTER A WITH ACUTE]";

La lettre á peut être écrite :

• en utilisant son point de code unique \x00e1 ;
• ou comme la combinaison des points de code de : a et de l'accent aigu \x0061\x0301.

Quelques méthodes qui peuvent être utilisées :

say "á".NFC;
say "á".NFD;
say "á".uniname;

NFC:0x<00e1>
NFD:0x<0061 0301>
LATIN SMALL LETTER A WITH ACUTE

NFC renvoie le point code unique.
NFD décompose le caractère et renvoie ses points de code.
uniname renvoie le nom du point de code.

Des caractères Unicode peuvent être utilisés en tant qu'identifiants :

my $Δ = 1;
$Δ++;
say $Δ;

En temps normal, toutes les tâches d'un programme s'effectuent de façon séquentielle. Ce n'est pas un grand problème si le temps d'exécution n'est pas crucial pour vous.

Perl 6 intègre de façon naturelle le lancement de tâches en parallèle.
À ce point, il est important de considérer que le parallélisme peut vouloir dire deux choses :

• parallélisme des tâches : deux (ou plus) expressions indépendantes lancées en parallèle ;
• parallélisme des données : une expression unique itérée sur une liste d'éléments en parallèle.

Commençons par ce dernier.

14-1-1. Parallélisme des données▲

my @tableau = (0..50000);                     #Remplissage du tableau
my @résultat = @tableau.map({ is-prime $_ }); #Appel de is-prime sur chaque élément
say now - INIT now;                           #Temps d'exécution du programme

my @tableau = (0..50000);                          #Remplissage du tableau
my @résultat = @tableau.race.map({ is-prime $_ }); #Appel de is-prime sur chaque élément
say now - INIT now;                                #Temps d'exécution du programme

my @tableau = (1..1000);
my @résultat = @tableau.race.map( {$_ + 1} );
@résultat>>.say;

my @tableau = (1..1000);
my @résultat = @tableau.hyper.map( {$_ + 1} );
@résultat>>.say;

14-1-2. Parallélisme des tâches▲

my @tab1 = (0..49999);
my @tab2 = (2..50001);

my @résultat1 = @tab1.map( {is-prime($_ + 1)} );
my @résultat2 = @tab2.map( {is-prime($_ - 1)} );

say @résultat1 eqv @résultat2;

say now - INIT now;

my @tab1 = (0..49999);
my @tab2 = (2..50001);

my $promesse1 = start @tab1.map( {is-prime($_ + 1)} ).eager;
my $promesse2 = start @tab2.map( {is-prime($_ - 1)} ).eager;

my @résultat1 = await $promesse1;
my @résultat2 = await $promesse2;

say @résultat1 eqv @résultat2;

say now - INIT now;