De Perl 5 à Perl 6 - annexe 1

use v6; # utilisation de Perl 6

# ceci est un commentaire (même chose qu'en Perl 5)

#`{ Ceci
est un 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. }

my $pi #`{{{
Commentaire multiligne utilisant plusieurs accolades (ou crochets)
→ Ce commentaire est ouvert avec trois accolades ouvrantes.
→ Il faut le fermer avec trois accolades fermantes }.
 }}} = 3.14159;
say "Pi is: $pi";   # Affiche : 3.14159

Voir aussi le chapitre Commentaires de la première partie du tutoriel.

Pour les appels de méthodes, la flèche «->» est remplacée par le point «.» (la concaténation, qui utilisait le point, est maintenant faite avec le tilde «~»).

$personne->nom  # Perl 5
$personne.nom   # Perl 6

# Appel d'une méthode dont le nom n'est connu qu'à l'exécution:

$objet->$methodname(@args);  # Perl 5
$objet."$methodname"(@args); # Perl 6

Perl 5 est très laxiste sur les espaces blancs : on peut en mettre ou ne pas en mettre presque partout.

Perl 6 ne veut pas limiter la créativité du programmeur, mais le besoin de pouvoir établir une grammaire cohérente, déterministe et extensible travaillant en une seule passe et fournissant des messages d'erreurs qui soient une réelle aide au programmeur a conduit à adopter un compromis. Il en résulte qu'il y a quelques endroits où les espaces blancs sont obligatoires et d'autres où ils sont proscrits.

Pas d'espace autorisé avant la parenthèse ouvrant une liste d'arguments

substr ($s, 4, 1); # Perl 5 (en Perl 6 ce code essaierait de passer un
                   #         seul argument de type List à substr)
substr($s, 4, 1);  # Perl 6
substr $s, 4, 1;   # Perl 6 - le + simple est d'omettre les parenthèses

Espace obligatoire après les mots-clefs

my($alpha, $bravo);         # Perl 5. En Perl 6, essaie d'appeler 
                            # la fonction my()

my ($alpha, $bravo);        # Perl 6

if($a < 0) { ... }          # Perl 5, erreur en Perl 6
if ($a < 0) { ... }         # Perl 6
if $a < 0 { ... }           # Perl 6, plus idiomatique sans parenthèses

while($x-- > 5) { ... }     # Perl 5, erreur en Perl 6
while ($x-- > 5) { ... }    # Perl 6
while $x-- > 5 { ... }      # Perl 6, plus idiomatique sans parenthèses

Pas d'espace autorisé après un opérateur préfixé ou avant un opérateur postfixé ou postcirconfixé (y compris pour indices des tableaux et des hachages)

$seen {$_} ++; # Perl 5
%seen{$_}++;   # Perl 6

À noter cependant que l'on peut utiliser l'opérateur unspace «\» pour ajouter des espaces (et même des commentaires) presque n'importe où :

# Perl 5
my @books = $xml->parse_file($file)          # commentaire quelconque
                ->findnodes("/library/book");

# Perl 6
my @books = $xml.parse-file($file)\          # commentaire quelconque
                .findnodes("/library/book");

Perl 5 et Perl 6 ont à peu près la même notion du vrai et du faux (les nombres 0, 0.0 et la chaîne vide sont faux, presque tout le reste est vrai), à cette différence près que, contrairement à Perl 5, Perl 6 considère la chaîne "0" comme vraie.

Perl 6 possède un type booléen (Bool) définissant des valeurs True et False.

Il n'y a pas de valeur undef en Perl 6. Une variable déclarée, mais non initialisée, est évaluée à son type. Mais le type sans valeur définie renvoie une valeur fausse dans un contexte booléen, si bien qu'une variable non initialisée renvoie une valeur fausse, comme le fait undef en Perl 5.

my $x; say $x;               # affiche: (Any)
my Int $i; say $i;           # affiche: (Int)
say "Défini" if $i;          # n'affiche rien, $i est évalué à False
say "Non défini" unless $i;  # affiche "Non défini"

• En Perl 5, les tableaux et les hachages ont des sigils (signes précédant le nom des variables, comme $, @, %, etc.) qui changent selon la manière dont on accède à la variable. Ce n'est plus le cas en Perl 6, les sigils sont invariants, on peut considérer qu'ils font partie du nom de la variable.
• Le sigil $ est utilisé pour les variables scalaires (« une seule chose ») et n'est plus utilisé pour accéder aux éléments individuels d'un tableau ou d'un hachage.
• Le sigil @ est utilisé pour accéder aux variables de type tableau (par exemple : @mois, @mois[2], @mois[2, 4]) et n'est plus utilisé pour les tranches de hachage.
• Le sigil % est utilisé pour accéder aux variables de type hachage (par exemple : %calories, %calories<pomme>, %calories<poire prune>) et n'est plus utilisé pour les tranches clef-valeur de tableaux.
• Le sigil & est utilisé de façon cohérente (et sans l'aide d'un antislash «\») pour prendre une référence sur une fonction ou un opérateur nommé sans l'invoquer.

my $sub = \&toto; # Perl 5
my $sub = &toto;  # Perl 6

callback => sub { say @_ } # Perl 5: ne peut passer directement la sub
callback => &say           # Perl 6: & transforme une fonction en nom

Voir aussi le chapitre 2 de la première partie de ce tutoriel.

Les opérations d'accès aux valeurs d'un tableau ne modifient plus le sigil «@», quel que soit le mode d'accès.

# accès à un élément d'un tableau
say $mois[2]; # Perl 5
say @mois[2]; # Perl 6 - @ au lieu de $

# tranche d'un tableau
say join ',', @mois[6, 8..11]; # Perl 5 et Perl 6

# tranche par clef-valeur
say join ',', %mois[6, 8..11];    # Perl 5
say join ',', @mois[6, 8..11]:kv; # Perl 6 - @ au lieu de %; 
                                  # utilisation de l'adverbe :kv

Les opérations d'accès aux valeurs d'un hachage ne modifient plus le sigil «%», quel que soit le mode d'accès.

say $calories{"pomme"}; # Perl 5
say %calories{"pomme"}; # Perl 6 - % au lieu de $

say $calories{pomme}; # Perl 5
say %calories<pomme>; # Perl 6 - chevrons; % au lieu de $

# Tranches
say join ',', @calories{'poire', 'prune'}; # Perl 5
say join ',', %calories{'poire', 'prune'}; # Perl 6 - % au lien de @
say join ',', %calories<poire prune>;      # Perl 6 (version + concise)

# Tranches clefs-valeurs
say join ',', %calories{'poire', 'prune'};  # Perl 5
say join ',', %calories{'poire, 'prune}:kv; # Perl 6 - avec:kv
say join ',', %calories<poire prune>:kv;    # Perl 6 (plus propre)

Les créateurs de références vers des tableaux [...] et des hachages {...} restent inchangés.

En Perl 5, les références vers des tableaux, hachages ou fonctions sont renvoyées lors de leur création. Les références vers des variables ou fonctions existantes sont créées à l'aide de l'opérateur «\».

En Perl 6, il en va de même pour les tableaux, hachages et fonctions anonymes. Mais les références vers des fonctions nommées sont générées en préfixant le nom de la fonction avec le sigil «&amp;». On utilise le contexte item pour générer des références vers des variables nommées.

my $aref = [ 1, 2, 9 ];          # Perl 5 et Perl 6
my $href = { A => 98, Q => 99 }; # Perl 5 et Perl 6

my @aaa = <1 4 6>;
my $aref =     \@aaa ;  # Perl 5
my $aref = item(@aaa);  # Perl 6
# ou : 
my $aref =  @aaa.item;  # Perl 6, notation objet/méthode

my $href =      \%hhh;  # Perl 5
my $href = item(%hhh);  # Perl 6

my $sref =     \&foo;   # Perl 5
my $sref =      &foo;   # Perl 6

En Perl 5, la syntaxe pour déréférencer une référence entière est d'utiliser le sigil du type voulu et des accolades autour de la référence.

En Perl 6, les accolades sont remplacées par des parenthèses.

# Perl 5
    say      ${$scalar_ref};
    say      @{$arrayref  };
    say keys %{$hashref   };
    say      &{$subref    };

# Perl 6
    say      $($scalar_ref);
    say      @($arrayref  );
    say keys %($hashref   );
    say      &($subref    );

À noter qu'en Perl 5 comme en Perl 6, les accolades ou parenthèses sont souvent optionnelles, mais leur omission peut rendre le code moins clair.

En Perl 5, l'opérateur flèche «->» est utilisé pour un accès unique à une référence composée ou pour appeler une fonction à l'aide de sa référence. En Perl 6, c'est l'opérateur point «.» qui joue ce rôle :

# Perl 5
    say $arrayref->[7];
    say $hashref->{'Tartempion'};
    say $subref->($toto, $titi);

# Perl 6
    say $arrayref.[7];
    say $hashref.{'Tartempion'};
    say $subref.($toto, $titi);

La documentation Pod (qui s'appelait POD, Plain Ol' Documentation, tout en lettres capitales, en Perl 5) a subi des changements entre Perl 5 et Perl 6. La principale différence est qu'il faut insérer un Pod entre des directives =begin pod et =end pod. Plus généralement, le Pod de Perl 6 est conçu pour être plus régulier et uniforme, un peu plus compact et nettement plus expressif que le POD de Perl 5, tout en limitant dans la mesure du possible les différences.

Les autres modifications sont plus des détails qui peuvent néanmoins s'avérer irritants quand on est habitué au POD de Perl 5.

Le mieux est sans doute d'utiliser l'interpréteur Perl pour vérifier son Pod, en utilisant l'option --doc de la ligne de commande, par exemple perl6 --doc pod_quelconque.pod, ce qui affichera tout problème sur la sortie d'erreur. (Selon l'emplacement où Perl 6 est installé et la façon dont il a été installé, il peut être nécessaire de spécifier l'emplacement de Pod::To::Text.)

La documentation Pod est un point suffisamment important pour mériter ce paragraphe, mais nous ne pouvons vraiment pas entrer dans les détails ici.

Pour plus de détails sur le Pod de Perl 6, voir la Synopsis S26.

En Perl 5, ces opérateurs renvoient -1, 0 ou 1. En Perl 6, ils renvoient Order::Increase, Order::Same, or Order::decrease. Cela ne fait une différence que si nous voulons écrire notre propre fonction personnalisée de comparaison.

L'opérateur cmp de Perl 5 est remplacé par leg, qui force une comparaison en contexte de chaîne.

L'opérateur <=> est inchangé et force une comparaison en contexte numérique.

En Perl 6, l'opérateur cmp se comporte soit comme cmp, soit comme <=>, selon le type de ses arguments.

Les opérateurs de liaison (pour les regex) «=~ » et «!~» sont remplacés respectivement par «~~» et «!~~».

L'opérateur ~~ de reconnaissance intelligente de Perl 5 n'a pas changé sur le fond, mais les règles gouvernant ce qui est reconnu dépendent du type des arguments, et, les types ayant été très approfondis en Perl 6, ces règles sont loin d'être les mêmes en Perl 5 et en Perl 6.

Surtout, tout semble indiquer que l'opérateur de comparaison intelligente fonctionne de façon satisfaisante en Perl 6, alors que son implémentation en Perl 5 laisse suffisamment à désirer pour que son utilisation soit dépréciée (ou plus exactement qu'il soit déclaré « expérimental ») dans les dernières versions de Perl 5.

Pour plus de détails sur le fonctionnement de «~~», voir Smart Matching.

Comme en Perl 5, les opérateurs «!» et «-» assurent respectivement la négation logique et arithmétique (opérateurs non bit à bit).

En Perl 5, le comportement des opérateurs &  |  ^ dépendait du type des arguments : par exemple, 31 | 33 ne renvoie pas la même chose que "31" | "33".

En Perl 6, ces opérateurs à un seul caractère ont été supprimés et sont remplacés par des opérateurs à deux caractères qui forcent le contexte approprié.

# Opérateurs infixés (deux arguments, un de chaque côté de l'opérateur)
+&  +|  +^  Et, Ou, Ou exclusif: Numérique
~&  ~|  ~^  Et, Ou, Ou exclusif: Chaîne de caractères
?&  ?|  ?^  Et, Ou, Ou exclusif: Booléen

# Opérateurs préfixés (un argument, après l'opérateur)
+^  Non: Numérique
~^  Non: Chaîne de caractères
?^  Non: Booléen (même chose que l'opérateur !)

Les opérateurs de décalage de bits << et >> sont remplacés par +< et +> :

say 42 << 3; # Perl 5
say 42 +< 3; # Perl 6

Il est beaucoup moins fréquent en Perl 6 qu'en Perl 5 d'utiliser des références, si bien que l'on a aussi moins souvent besoin d'un opérateur de déréférencement. Mais en cas de besoin, l'opérateur de déréférencement est le point «.» et non plus la flèche «->» (voir aussi § 2.9), et le point remplace aussi la flèche pour les appels de méthodes. Donc, une construction $tabl_ref->[3] de Perl 5 devient $tabl_ref.[3] en Perl 6.

En Perl 5, « => » agissait comme une virgule et transformait aussi ce qui précédait en une chaîne de caractères.

En Perl 6, « => » est l'opérateur de paire (type Pair), ce qui est assez différent en principe, mais fonctionne de la même façon dans un bon nombre de situations.

Par exemple, pour initialiser un hachage ou passer des arguments à une fonction attendant une référence à un hachage, l'utilisation est la même :

# Marche en Perl 5 et en Perl 6
my %hachage = ( AAA => 1, BBB => 2 );
prends_le_butin( 'diamants', { niveau => 'élevé', nombre => 9 });
             # Noter les accolades, le second argument est un hashref

Mais si vous utilisiez cet opérateur pour ne pas devoir mettre de guillemets sur une partie d'une liste, ou pour passer une liste plate d'arguments de type CLEF, VALEUR, CLEF, VALEUR, alors il y a de bonnes chances qu'utiliser ainsi => ne fonctionne pas comme prévu. La solution de contournement consiste à remplacer la grosse virgule par une virgule ordinaire et à ajouter des guillemets ou des apostrophes à son argument de gauche. Ou vous pouvez modifier l'API de la fonction pour qu'elle accepte un hachage en argument.

Une meilleure solution à long terme est de modifier l'API de la fonction pour qu'elle accepte des paires. Mais cela oblige à modifier d'un seul coup tous les appels de la fonction.

# Perl 5
sub prends_le_butin {
    my $butin = shift;
    my %options = @_;
    # ...
}
prends_le_butin( 'diamants', niveau => 'élevé', nombre => 9 );
              # Noter: pas d'accolade cette fois

# Perl 6, API d'origine
sub prends_le_butin ( $butin, *%options ) { 
              # L'astérisque * signifie de prendre tous les params
    ...
}
prends_le_butin( 'diamants', niveau => 'élevé', nombre => 9 ); 
              # Noter: pas d'accolade dans cette API

# Perl 6, API modifiée pour spécifier les options valides
# Les deux-points avant les sigils signifient que l'on attend une paire
# dont la clef a le même nom que la variable

sub prends_le_butin ( $butin, :$niveau?, :$nombre = 1 ) {
    # Cette version va vérifier les arguments inattendus!
    ...
}
prends_le_butin( 'diamants', noveau => 'élevé' ); 
              # Génère une erreur en raison de la faute                                           
              # d'orthographe sur le nom du paramètre (noveau)

L'opérateur point «.» étant maintenant un opérateur d'appel de méthode et de déréférencement, l'opérateur de concaténation n'est plus le point, mais le tilde «~».

De même, l'opérateur d'affectation-concaténation n'est plus «.=», mais «~=».

Cet opérateur utilise désormais deux points d'interrogation au lieu d'un seul et deux caractères points d'exclamation au lieu du deux-points :

my $résultat = ( $note > 60 )  ? 'Réussi'  : 'Loupé'; # Perl 5
my $résultat = ( $note > 60 ) ?? 'Réussi' !! 'Loupé'; # Perl 6

En Per 5, x est l'opérateur de répétition. En contexte scalaire ou si l'opérande à sa gauche n'est pas entre parenthèses, x renvoie une chaîne de caractères. En contexte de liste et si l'argument à gauche est entre parenthèses, il répète la liste. Il fallait simplifier ces règles alambiquées.

En Perl 6, x répète les chaînes de caractères, quel que soit le contexte.

En Perl 6, le nouvel opérateur xx répète des listes, quel que soit le contexte.

# Perl 5
    print '-' x 80;            # Affiche une rangée de 80 tirets
    @uns = 1 x 80;             # Un tableau contenant un seul élément,
                               # une chaîne de 80 fois le chiffre 1
    @uns = (1) x 80;           # Un tableau de 80 chiffres 1
    @uns = (5) x @uns;         # Met à 5 tous les éléments de @uns
# Perl 6
    print '-' x 80;            # Inchangé
    @uns = 1 x 80;             # Inchangé
    @uns = 1 xx 80;            # Parenthèses plus nécessaires
    @uns = 5 xx @uns;          # Parenthèses plus nécessaires

Il existe un opérateur de citation qui garantit des chaînes absolument littérales, sans aucune interpolation, c'est «Q» ou «｢…｣» (à supposer que vous sachiez comment obtenir «｢» et «｣» sur votre clavier). Même les échappements par antislash ne s'appliquent pas. Par exemple :

my $littéral = Q{Cela reste une accolade fermante → \};
# renvoie la chaîne : "Cela reste une accolade fermante → \"

L'opérateur «q» fait ce à quoi l'on s'attend en venant de Perl 5, à savoir pas d'interpolation à l'exception des séquences d'échappement par antislash. Par exemple :

my $var-échap = q{Ce n'est pas une accolade fermante → \} mais ceci  → }; 
renvoie :  "Ce n'est pas une accolade fermante → } mais c'est ceci  →"

Comme en Perl 5, vous pouvez utiliser les apostrophes ou guillemets simples ('…') pour obtenir le même résultat.

L'opérateur «qq» autorise l'interpolation des variables (de même que les guillemets doubles «"»). Cependant, par défaut, seules les variables scalaires sont interpolées. Pour interpoler les autres types de variables (tableaux, hachages, etc.), il faut les suffixer avec des crochets. Par exemple, @a = <1 2 3>; say qq/@a[] exemple@exemple.com/; donne : 1 2 3 exemple@exemple.com. Toutefois, l'interpolation de hachages donne actuellement un résultat visuellement quelque peu inattendu :

my %hachage = 1 => 2, 3 => 4;
say "%a[]";   # affiche : 1       2 3     4.

comme si les clefs étaient séparées des valeurs par des tabulations et les valeurs des clefs suivantes par des espaces. Il est également possible d'interpoler dans des chaînes de caractères du code Perl 6 en le mettant entre accolades :

my $x = 5;
say "Le double de $x est {$x * 2} et le carré de $x est {$x ** 2}.";
# Imprime : Le double de 5 est 10 et le carré de $x est 25.
say qq/Le double de $x est {$x * 2} et le carré de $x est {$x ** 2}./;
# idem

L'opérateur de citation de mots «qw» fonctionne comme en Perl 5 et peut aussi être rendu par <...>. Par exemple, qw/ a b c/ est équivalent à <a b c>. Cet opérateur ne fait pas d'interpolation. Il existe une version, qqw, qui fait l'interpolation des variables. Par exemple :

my $a = 42;         # la variable $a n'a rien de spécial en Perl 6
say qqw/$a b c/;    # -> 42 b c

L'opérateur de citation du shell (appel de fonctions système) est qx, comme en Perl 5, mais il faut noter que les accents graves (ou backticks) `...` ne fonctionnent pas en Perl 6 et que les variables ne sont pas interpolées dans les chaînes qx. Pour interpoler les variables, il suffit de remplacer qx par qqx.

L'opérateur qr n'existe plus en Perl 6, mais les regex de Perl 6 offrent des possibilités bien plus puissantes, comme le mécanisme des regex nommées.

L'opérateur de translittération tr/// n'est pas bien documenté à l'heure actuelle, mais il semble fonctionner comme en Perl 5, avec cependant cette différence que les intervalles de caractères s'écrivent «a..z», donc avec l'opérateur standard d'intervalle (au lieu de «a-z» en Perl 5). Il existe une version méthode de tr///, mieux documentée, qui s'appelle .trans. Cette méthode utilise des listes de paires :

$x.trans(['a'..'c'] => ['A'..'C'], ['d'..'q'] => ['D'..'Q'], ['r'..'z'] => ['R'..'Z']);

Les deux côtés de chaque paire sont interprétés comme le ferait tr///. Cela donne une grande flexibilité. Voir http://...#Transliteration pour une description complète.

L'opérateur y///, qui était en Perl 5 un simple synonyme de tr///, a été abandonné en Perl 6.

Les documents « ici même » (heredocs) sont spécifiés de façon un peu différente en Perl 6 : il faut utiliser le mot-clef :to immédiatement après l'opérateur de citation, par exemple, la séquence q:to/FIN commence un document se terminant par FIN. Les échappements et l'interpolation dépendent de l'opérateur de citation utilisé (citation littérale avec Q, échappement des antislashs avec q et interpolation des variables avec qq.

Ce paragraphe ne fait que résumer les principaux opérateurs de citation et assimilés ressemblant à ceux de Perl 5. Le chapitre Citation et analyse lexicale du tutoriel explique plus en détail la logique de fonctionnement du très puissant mécanisme sous-jacent de citation de chaînes de caractères, permettant à l'utilisateur de maîtriser très finement les caractéristiques de sa chaîne.

Pour encore plus de détails, voir http://doc.perl6.org/language/quoting.

Comme l'opérateur « diamant » (ou « carreau ») <...> est un opérateur de citation de mots (cf. § 3.9 ci-dessus), il n'est plus possible d'utiliser <> pour lire les lignes d'un fichier. Pour ce faire, il faut soit créer un objet IO à partir d'un nom de fichier, soit utiliser un descripteur de fichier (filehandle) ouvert et, dans les deux cas, utiliser la méthode .lines sur l'objet ou le descripteur :

# Objet IO :
my @tableau-de-lignes = "filename".IO.lines;  # remarquer la concision
# Descripteur de fichier (ou FH) :
my $fh = open "filename", :r;                 # :r -> FH en lecture
my @a = $fh.lines;

Pour lire un fichier ligne à ligne itérativement :

for 'gigantesque-csv'.IO.lines -> $line {
    # Traiter $line
}

À noter que la syntaxe utilisant for ne serait pas recommandée en Perl 5 pour un très gros fichier, car cela impliquerait de stocker l'ensemble du fichier dans un tableau temporaire et pourrait saturer la mémoire ; en Perl 6, cela ne pose aucun problème grâce à la paresse de l'opérateur : la ligne n'est lue que quand on en a besoin et il n'y a jamais plus d'une ligne en mémoire. Noter également l'utilisation ici d'un « bloc pointu » avec la syntaxe -> (voir le chapitre sur les Boucles du tutoriel).

Pour avaler d'un seul coup (to slurp) tout un fichier dans un scalaire, il faut utiliser la méthode .slurp. Par exemple :

my $x = "filename".IO.slurp;

# Ou, façon procédurale (non objet) encore plus simple :
my $x = slurp "filename";

# Ou, avec un FH :
my $fh = open "filename", :r;
my $x = $fh.slurp;

Le descripteur de fichier en entrée magique ARGV est remplacé par $*ARGFILES et le tableau @ARGV des arguments de la ligne de commande par @*ARGS.

Pour écrire dans un fichier :

my $fh = open "filename", :w;     # :w -> ouverture en écriture
$fh.say("données, trucs, bidules");
$fh.close;

Voir aussi § 9. Pour plus de détails sur les entrées-sorties, voir http://.../language/io.

En Perl 5, le « .. » était deux opérateurs complètement différents, selon le contexte. En contexte de liste, c'est l'opérateur bien connu de création d'intervalles. Il y a beaucoup à dire sur les intervalles en Perl 6 (par exemple, il est possible d'inclure ou non les bornes de l'intervalle dans la liste créée, ainsi 1..^5 exclut la borne supérieure de l'intervalle et est donc équivalent à 1..4), mais un intervalle de Perl 5 ne devrait pas nécessiter de traduction en Perl 6.

En contexte scalaire, .. et ... étaient en Perl 5 les opérateurs flip-flop, beaucoup moins utilisés. Ils ont été remplacés en Perl 6 par les opérateurs ff et fff.

Ces deux opérateurs sont évalués à faux jusqu'à ce que $_ soit reconnu par le premier argument, puis à vrai jusqu'à ce que le second argument reconnaisse $_. L'exemple ci-dessous illustre la différence assez subtile entre les deux. À noter qu'il existe également des versions ^ff, ^fff, ff^, fff^, ^ff^ et ^fff^ qui renvoient faux pour la borne du premier ou du second argument où se trouve l'accent circonflexe.

# Dès que le premier argument reconnaît $_, ff renvoie vrai puis 
# évalue le second. Ci-dessous, AB reconnaît B et ff renvoie faux
for <X Y Z AB C D B E F> {
    say $_ if /A/ ff /B/;  # imprime seulement "AB"
}

# fff n'évalue pas le second argument pour la valeur de $_ qui
# a été reconnue par le premier argument
for <X Y Z AB C D B E F> {
    say $_ if /A/ fff /B/; # Imprime "AB", "C", "D" et "B"
}

# ^fff renvoie faux quand le premier argument reconnaît $_ puis
# renvoie vrai jusqu'à ce que le second argument reconnaisse $_
for <X Y Z AB C D B E F> {
    say $_ if /A/ fff /B/; # Imprime "AB", "C" et "D", mais pas "B"
}
# fff^ renvoie faux dès que le second argument reconnaît $_
for <X Y Z AB C D B E F> {
    say $_ if /A/ fff /B/; # Imprime "AB", "C" et "D", mais pas "B"
}

Voir aussi le chapitre Opérateurs de la seconde partie du tutoriel et celui sur la création de nouveaux opérateurs dans l'annexe 2.

3-1-1. Conditions if elsif else unless▲

if (my $x = faire_truc()) {...}  # Perl 5, marche aussi en Perl 6
if faire_truc() -> $x {...}      # Perl 6, idiomatique

next if $ligne ~~ /^\s+#/;
say "Je l'emporte !" if gagné();

3-1-2. Branchements multiples given-when▲

given EXPR {
    when EXPR { ... }
    when EXPR { ... }
    default { ... }
}

given $valeur {
    when "une reconnaissance" {
        faire_une_chose();
    }
    when "une autre reconnaissance" {
        faire_autre_chose();
    }
    default {
        faire_la_chose_par_defaut();
    }
}

for 42, 43, "toto", 44 {
    when Int { .say }   # .say sans invoquant imprime la valeur de $_
    default  { say "Pas un Int" }
}
# -> 42 43 Pas un Int 44

3-2-1. Boucles while et until▲

while (my $x = faire_truc()) {...}  # Perl 5, marche aussi en Perl 6
while faire_truc() -> $x {...}      # Perl 6

while (<$IN_FH>)  { } # Perl 5
for $IN_FH.lines { }  # Perl 6

3-2-2. Boucles for et foreach▲

for  ( my $i = 1; $i <= 10; $i++ ) { ... } # Perl 5
loop ( my $i = 1; $i <= 10; $i++ ) { ... } # Perl 6

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

for my $cli (@clients)  {...}    # Perl 5; lecture et écriture
for @clients  -> $cli   {...}    # Perl 6; lecture seule
for @clients <-> $cli   {...}    # Perl 6; lecture et écriture

for (@clients)      {...}    # Perl 5; variable $_ par défaut
for @clients        {...}    # Perl 6; $_ en lecture seule
for @clients <-> $_ {...}    # Perl 6; $_ est en lecture et écriture

3-2-3. Instructions de contrôle de flux▲

# Perl 5
    my $str = '';
    for (1..5) {
        next if $_ % 2 == 1;
        $str .= $_;
    }
    continue {
        $str .= ':'
    }
# Perl 6
    my $str = '';
    for 1..5 {
        next if $_ % 2 == 1;
        $str ~= $_;
        NEXT {
            $str ~= ':' ;  # noter l'opérateur de concaténation
        }
    }

Voir aussi les chapitres consacrés aux Principales structures de contrôle et aux Comparaisons du tutoriel.

Les fonctions internes qui acceptaient un bloc de code nu suivi, sans virgule, du reste des arguments doivent maintenant avoir une virgule après le bloc de code et avant la suite des arguments, par exemple map, grep ou sort :

my @results = grep { $_ eq "bars" } @foo;       # Perl 5
my @results = grep { $_ eq "bars" }, @foo;      # Perl 6

my @sorted  = sort { $a <=> $b }, @unsorted;    # Perl 5
my @sorted  = sort { $^a <=> $^b }, @unsorted;  # Perl 6
my @sorted  = @unsorted.sort: { $^a <=> $^b };  # Perl 6, autre méthode

Les deux fonctions delete et exists sont transformées en des adverbes (arguments nommés pour des fonctions, ou parfois sur d'autres objets, préfixés par le signe deux-points) opérant sur les indices de tableaux ou clefs de hachages.

# delete

my $valeur-effacée = delete $hash{$clé};  # Perl 5
my $valeur-effacée = %hash{$clé}:delete;  # Perl 6 

my $valeur-effacée = delete $array[$i];   # Perl 5
my $valeur-effacée = @array[$i]:delete;   # Perl 6 

# exists

say "L'élément existe" if exists $hash{$key};  # Perl 5
say "L'élément existe" if %hash{$key}:exists;  # Perl 6 

say "L'élément existe" if exists $array[$i];   # Perl 5
say "L'élément existe" if @array[$i]:exists;   # Perl 6

4-3-1. Généralités▲

my $abs = abs($x);   # ou sans parenthèses : my $abs = abs $x;
my $abs = $x.abs;    # syntaxe de méthode

my $val = -5.abs;   # ERRONÉ : évalué comme -(5.abs) et retourne -5
my $val = (-5).abs; # Correct: retourne 5

my $val = .abs;   # équivalent à : my $val = $_.abs;

4-3-2. Liste alphabétique de fonctions Perl 5 et équivalences▲

En Perl 5, les reconnaissances et les substitutions sur une variable s'effectuent avec l'opérateur de liaison de regex =~.

En Perl 6, c'est l'opérateur ~~ de reconnaissance intelligente (smart match) qui est utilisé.

next if $ligne  =~ /statique/  ; # Perl 5
next if $ligne  ~~ /statique/  ; # Perl 6

next if $ligne  !~ /dynamique/ ; # Perl 5
next if $ligne !~~ /dynamique/ ; # Perl 6

$ligne =~ s/abc/123/;            # Perl 5
$ligne ~~ s/abc/123/;            # Perl 6

On peut également utiliser les nouvelles méthodes .match and .subst. Mais la méthode .subst ne modifie pas la chaîne d'origine (elle ne fait que renvoyer la chaîne modifiée si la substitution a réussi).

Les modificateurs ou adverbes sont déplacés de la fin vers le début de la regex. Ceci peut vous obliger à ajouter le m optionnel dans un motif de type /abc/.

next if $ligne =~    /statique/i ; # Perl 5
next if $ligne ~~ m:i/statique/  ; # Perl 6

Par défaut, les espaces positionnés dans les motifs ne jouent pas de rôle dans les reconnaissances (autrement dit, ils sont ignorés).

say "Vrai" if "abc" ~~ /a b c/; # imprime Vrai (mais émet un warning)

Comme en Perl 5, on peut utiliser \s pour reconnaître un espace de type quelconque (espace proprement dit, tabulation, saut de ligne, etc.), et \s+ pour plusieurs. La séquence ' ' permet de reconnaître un seul espace blanc. De même, \t, \h et \v reconnaissent respectivement des tabulations, des espaces horizontaux et des espaces verticaux.

Le modificateur :s (ou :sigspace) permet de tenir compte littéralement des espaces :

say "Vrai" if "abc"  ~~ m:s/ab c/; # n'imprime rien, non reconnu
say "Vrai" if "ab c" ~~ m:s/ab c/; # Vrai

On peut obtenir le même résultat avec la syntaxe simplifiée ms/ab c/ pour définir le motif.

Des détails complémentaires sont disponibles dans le paragraphe Reconnaissance du tutoriel.

Si vous avez une expression régulière Perl 5 complexe à utiliser dans un programme Perl 6, vous pouvez la garder telle quelle en disant à Perl 6 d'utiliser la syntaxe et la sémantique des expressions régulières Perl 5 au moyen du modificateur :P5 ou de l'adverbe :Perl5.

next if $ligne =~ m/[aeiou]/   ;    # Perl 5
next if $ligne ~~ m:P5/[aeiou]/   ; # Perl 6, avec le modificateur P5
next if $ligne ~~ m:Perl5/[aeiou]/; # Perl 6, avec l'adverbe Perl5
next if $ligne ~~ m/  <[aeiou]> / ; # Perl 6, nouvelle syntaxe des
                                    # classes de caractères

Nous ne pouvons les énumérer toutes, mais, souvent, au lieu d'être entourées de parenthèses (…), les reconnaissances spéciales seront entourées de chevrons <...>.

Ainsi, pour les classes de caractères :

De même pour les assertions avant ou arrière :

Dans les alternatives en Perl 5, c'est le premier motif reconnu qui gagne.

Avec l'opérateur d'alternative |, Perl 6 examine tous les termes de l'alternative (sans doute en parallèle), et en cas de reconnaissances multiples, c'est le motif le plus long qui est retenu.

Pour obtenir le comportement de Perl 5 (premier motif reconnu), il suffit d'utiliser l'opérateur ||.

Voir aussi les chapitres Regex (ou règles) et Les regex, le retour du tutoriel, le chapitre sur les regex et les grammaires de l'annexe 2 et l'article beaucoup plus complet Les regex et les grammaires de Perl 6 : une expressivité sans précédent.

Le mode strict et les warnings sont activés par défaut.

Les fonctions qui généraient une exception si le module autodie était utilisé déclenchent maintenant par défaut une exception, sauf si le programme teste explicitement leur valeur de retour.

# Perl 5
open my $i_fh, '<', $fic_in;  # échoue silencieusement en cas d'erreur
use autodie;
open my $o_fh, '>', $fic_out; # exception en cas d'erreur

# Perl 6
my $i_fh = open $input_path,  :r; # exception en cas d'erreur
my $o_fh = open $output_path, :w; # exception en cas d'erreur

Les modules base et parent sont remplacés en Perl 6 par le mot-clef is dans la déclaration de la classe.

# Perl 5
package Chien;
use base qw(Animal);

# Perl 6
class Chien is Animal;

Ces modules sont sans objet en Perl 6.

Les entiers (type Int) ont maintenant une précision arbitraire, de même que le numérateur des rationnels (type Rat). Le dénominateur des types Rat est limité à 2⁶⁴ (2 ** 64), après quoi il passe en type Num pour ne pas pénaliser les performances. Si vous avez besoin d'un Rat avec un dénominateur de précision arbitraire, alors il faut utiliser le type FatRat.

En Perl 6, constant déclare une variable, au même titre que my, sauf que la valeur de la variable est verrouillée à la valeur de son expression d'initialisation (évaluée au moment de la compilation).

Donc, il faut remplacer le => de Perl 5 par un opérateur = d'affectation simple et, en principe, ajouter un sigil.

use constant DEBUG => 0; # Perl 5
constant $DEBUG = 0;     # Perl 6

use constant pi => 4 * atan2(1, 1); # Perl 5
# pi, e et i sont des constantes prédéfinies en Perl 6

# NB: le sigil $ n'est pas indispensable, un "mot nu" fonctionne aussi:
constant nombre_d_or = (5**(1/2)+1)/2;  # (1.61803398874989)
say nombre_d_or ** 2;                   #  2.61803398874989
say 1 / nombre_d_or;                    #  0.61803398874989
# il reste préférable pour permettre l'interpolation dans une chaîne
say "nombre_d_or";                      # nombre_d_or
constant $nombre_d_or = (5**(1/2)+1)/2; 
say "$nombre_d_or";                     # 1.61803398874989

Sans objet : les appels de méthodes utilisent toujours l'ordre de résolution de méthode C3.

Sans objet : en Perl 6, le code source est encodé par défaut en UTF-8.

L'utilisation de ce module pour déclarer des variables globales est maintenant déconseillée en Perl 5. Mieux vaut utiliser une déclaration avec l'opérateur our.

Modifiez votre code Perl 5 pour éviter l'utilisation de use vars avant de traduire votre code en Perl 6.

En Perl 5, une façon idiomatique de lire un fichier dans un tableau peut s'écrire comme suit :

open my $fh, "<", "file" or die "$!";
my @lines = <$fh>;
close $fh;

En Perl 6, c'est plus simple :

my @lines = "file".IO.lines;

N'essayez pas de gober un fichier et de diviser la chaîne résultante sur les caractères de fin de ligne, car ceci vous donnera un tableau dont le denier élément est un de plus que ce que vous attendez probablement (et c'est plus compliqué que prévu) :

# Création du fichier (de 3 lignes) à lire
   # spurt écrit directement dans un fichier ou une chaîne de caractères, sans
   # avoir besoin d'ouvrir puis fermer un descripteur
spurt "fic-test", q:to/END/;                        
Ligne 1
Ligne 2
Ligne 3
END
# Relecture du fichier
my @lignes = "fic-test".IO.slurp.split(/\n/);
say @lignes.elems;    #-> 4 éléments

9-1-1. Chemin de la bibliothèque des modules Perl▲

$ PERL5LIB="/some/module/lib" perl program.pl

$ PERL6LIB="/some/module/lib" perl6 program.p6

use lib '/some/module/lib';

Les variables $`, $& et $' n'existent plus en Perl 6 (remplacées pour l'essentiel par des variations sur $/) et, avec leur élimination, les problèmes de performances qu'elles pouvaient générer en Perl 5 disparaissent également.

En Perl 5, il est possible d'importer sélectivement seulement certaines fonctions d'un module donné :

use NomDeModule qw{toto titi};

En Perl 6, c'est dans le module que l'on spécifie les fonctions à exporter, en utilisant lors de la définition de ces fonctions le rôle is export, et toutes les fonctions munies de ce rôle seront exportées. Ainsi, le module Parler suivant

unit module Parler;

sub dit($a) is export {say "La personne dit $a" }
sub crie($a) is export {say "La personne crie $a"}
sub murmure($a) {say "La personne murmure $a" }

exporte les fonctions dit et crie, mais pas murmure.

Pour utiliser ce module, il suffit d'insérer la ligne use Parler; et les fonctions dit et crie seront disponibles :

Use Parler;

dit("Bonjour");          # "La personne dit bonjour"
crie ("Au secours!")      # "La personne crie au secours!"

Si l'on essaie d'utiliser la fonction murmure, une erreur Undeclared routine se produit à la compilation.

N'est-il alors plus possible d'importer sélectivement les fonctions comme en Perl 5 ? Si, c'est possible et ce serait dommage de s'en passer, mais c'est un peu plus compliqué parce que cela sort de la sémantique recherchée et oblige de descendre d'un niveau. Pour permettre ce comportement comme en Perl 5, il faut définir au sein du module une fonction EXPORT qui spécifie les fonctions à exporter et (dans l'implémentation actuelle de Rakudo) supprimer la déclaration de module Parler. (À noter que l'absence de déclaration de module n'est pas entièrement conforme à la Synopse 11, mais ça fonctionne.)

Le module Parler est maintenant simplement un fichier nommé Parler.pm contenant par exemple ce qui suit :

use v6;

sub EXPORT(*@import-list) {
    my %exportable-subs =
        '&dire' => &dit,
        '&crie' => &crie,
        ;
    my %subs-to-export;
    for @import-list -> $import {
        if grep $sub-name, %exportable-subs.keys {
            %subs-to-export{$sub-name} = %exportable-subs{$sub-name};
        }
    }
    return %subs-to-export;
}

sub dit($a, $b, $c) { say "Elle dit $a, $b, $c" }
sub crie($a) { say "Elle crie $a" }
sub murmure($z) { say "Elle murmure $z" }

Il faut remarquer que les fonctions ne sont plus exportées explicitement par le truchement du rôle is export. On définit à la place la fonction EXPORT qui spécifie les fonctions du module que l'on désire rendre disponible à l'exportation, puis on alimente un hachage contenant les fonctions qui seront réellement exportées. Le tableau @import_list est la liste de fonctions demandées par le code appelant dans sa clause use ..., ce qui permet à l'utilisateur du module d'importer sélectivement certaines des fonctions mises à sa disposition.

Pour n'importer que la fonction dit, il suffit d'écrire :

use Parler <dit>;
dit("Bonjour");       #  Elle dit Bonjour

On voit donc ici que, bien que la fonction crie soit exportable, elle ne sera pas disponible dans le code appelant :

use Parler <dit>;
dit("Bonjour");       #  Elle dit Bonjour
crie("Au secours");   #  "Undeclared routine: crie used at line 3"

Cependant, ceci fonctionnera :

use Parler <dit crie>;
dit("Bonjour");       #  Elle dit Bonjour
crie("Au secours");   #   Elle crie Au secours

À noter que la fonction murmure ne peut toujours pas être importée, même si elle est ajoutée dans la clause use, puisqu'elle ne figure pas dans le hachage %exportable-subs :

use Parler <dit crie>;
dit("Bonjour");       #  Elle dit Bonjour
murmure("Chut!");     #  "Undeclared routine: murmure used at line 3"

Pour faire fonctionner tout cela, il faut manifestement parcourir un chemin parsemé d'embûches. Dans l'utilisation normale dans laquelle on spécifie les fonctions à importer à l'aide du rôle is export, Perl 6 crée automatiquement la fonction EXPORT correcte. C'est la façon normale de faire. Bien que cela soit possible, il faut vraiment se demander soigneusement si ça vaut vraiment la peine de se lancer dans sa propre fonction EXPORT.

10-2-1. Module Data::Dumper▲

# Soit la structure de données suivante:
    my @array_of_hashes = (
        { NOM => 'pomme',   type => 'fruit' },
        { NOM => 'brocoli', type => 'non merci, sans façon' },
    );
# Perl 5
    use Data::Dumper;
    $Data::Dumper::Useqq = 1;
    print Dumper \@array_of_hashes; # Noter l'antislash
# Perl 6
    say @array_of_hashes.perl;   # .perl sur le tableau, pas 
                                 # sur une référence.

# Soient les variables suivantes 
# (noms des vars tirés des nombres Shadoks pour changer de toto) ;-)
  my ( $ga, $bu, $zo ) = ( 42, 44, 46 );
  my @meu = ( 16, 32, 64, 'Stop!' );
# Perl 5
  use Data::Dumper;
  print Data::Dumper->Dump(
      [     $ga, $bu, $zo, \@meu   ],
      [ qw(  ga   bu   zo   *meu ) ],
  );
# Affiche:
  $ga  = 42;
  $bu  = 44;
  $zo  = 46;
  @meu = (
           16,
           32,
           64,
           'Stop!'
         );
# Perl 6
  say [ :$ga, :$bu, :$zo, :@meu ].perl;
# Affiche
  ["ga" => 42, "bu" => 44, "zo" => 46, "meu" => [16, 32, 64, "Stop!"]]

10-2-2. Module Getopt::Long▲

# Perl 5
use 5.010;
use Getopt::longueur;
use utf8;
GetOptions(
  'longueur=i'  => \( my $longueur = 24        ), # numeric
  'fichier=s'   => \( my $data = 'fichier.dat' ), # string
  'verbeux'     => \( my $verbeux              ), # indicateur booléen
  ) or die;
say $longueur;
say $data;
say 'Bavard : ', ($verbeux ? 'oui' : 'non') if defined $verbeux;
# perl exemple.pl
    24
    fichier.dat
perl exemple.pl --fichier=toto --longueur=42 --verbeux
    42
    toto
    Bavard : oui

perl exemple.pl --longueur=abc
    Value "abc" invalid for option longueur (number expected)
    Died at c.pl line 3.

# Perl 6
sub MAIN ( Int :$longueur = 24, :fichier($data) = 'fichier.dat', Bool :$verbeux ) {
    say $longueur if $longueur.defined;
    say $data   if $data.defined;
    say 'Bavard : ', ($verbeux ?? 'oui' !! 'non');
}
# perl6 exemple.p6
    24
    fichier.dat
    Bavard : non
# perl6 exemple.p6 --fichier=toto --longueur=42 --verbeux
    42
    toto
    Bavard : oui
# perl6 exemple.p6 --longueur=abc
    Usage:
      c.p6 [--longueur=<Int>] [--fichier=<Any>] [--verbeux]

Le projet Blue Tiger est dédié à la modernisation automatique de code Perl. Il n'existe (pour l'instant) pas d'interface Web, il faut donc l'installer localement pour en tirer parti.

Il contient aussi un programme distinct de traduction des regex Perl 5 en Perl 6.

Le projet Perlito est un traducteur en ligne !

Ce projet est une suite de compilateurs croisés, dont l'un effectue une traduction de code Perl 5 en code Perl 6. Il dispose d'une interface Web permettant de l'utiliser depuis un navigateur Web sans installation logicielle préalable.

Le code de Larry Wall pour traduire de Perl 5 en Perl 6 a beaucoup vieilli et n'est (actuellement) plus viable pour les versions récentes de Perl 5.

MAD (Misch Attribute Decoration) est une option de configuration lorsque l'on construit un exécutable Perl depuis une distribution. Un exécutable Perl analyse et traduit le code source Perl qui lui est présenté en un arbre d'opérations (op-tree) et exécute ensuite le programme en parcourant cet arbre. En temps normal, tous les détails de cette analyse sont jetés à l'issue du processus. Si MAD a été activé, l'exécutable Perl sauvegarde les détails de cet arbre dans un fichier XML qui peut ensuite être retraité et transformé en code Perl 6 par un analyseur MAD.

Veuillez consulter le canal IRC #perl6 pour déterminer la meilleure version de Perl 5 à utiliser pour vos expériences avec MAD. En l'état actuel, attendez-vous à devoir bien bidouiller pour réussir à vous en servir.

Le module Inline::Perl5 de Perl 6 permet d'utiliser du code Perl 5 à l'intérieur d'un programme Perl 6. Son principal avantage est de permettre d'utiliser les modules Perl 5 du CPAN (y compris des modules XS contenant une partie écrite en C) depuis un programme Perl 6 et donc d'offrir accès à une grande partie de la vaste bibliothèque de modules Perl 5 du CPAN.

Certains modules ou « frameworks » particulièrement complexes ou « magiques » ne fonctionnent sans doute pas encore, mais il est par exemple possible depuis août 2014 d'utiliser un module assez pointu comme DBI depuis Perl 6.

L'outil standard d'installation de modules Perl 6 s'appelle Panda (livré en standard avec Rakudo Star). La procédure classique d'installation se déroule comme suit :

panda install Inline::Perl5
perl Makefile.PL
make
make test
make install

Dans le même ordre d'idée, rappelons la possibilité d'utiliser le modificateur :P5 ou l'adverbe :Perl5 pour utiliser les expressions régulières de Perl 5 dans un programme Perl 6 (voir § 6.4).

Le module Inline::Perl6 est en quelque sorte la réciproque du module présenté ci-dessus : c'est un module Perl 5 qui permet d'utiliser du code Perl 6 à l'intérieur d'un programme Perl 5. Pour ce faire, il intègre un Perl 6 Rakudo (MoarVM).

On peut imaginer utiliser ce module à deux types d'objectifs.

À des fins essentiellement pédagogiques (par exemple pour s'autoformer), on peut continuer à programmer en Perl 5, ou à utiliser un programme Perl 5 existant, mais commencer à se familiariser « sans douleur » avec les nouveautés syntaxiques ou sémantiques de Perl 6.

L'autre objectif plus pragmatique est de permettre l'utilisation en Perl 5 de certains concepts de Perl 6 absents ou moins puissants en Perl 5, ou plus simplement d'utiliser des méthodes Perl 6.

À noter que l'utilisation de ce module nécessite d'installer sur l'ordinateur une version à jour de Perl 6 Rakudo et du module Inline::Perl5 pour Perl 6 décrit au § 12.4 ci-dessus.