De Perl 5 à Perl 6

Les jonctions sont des superpositions de valeurs non ordonnées. Les opérations sur les jonctions s'exécutent séparément sur tous les éléments de la jonction (peut-être même en parallèle dans des threads différents si le compilateur le supporte) et une nouvelle jonction du même type est assemblée à partir des résultats partiels.

Il y a quatre types de jonctions, qui ne diffèrent que quand elles sont évaluées en contexte booléen. Les types disponibles sont any, all, one et none. En contexte booléen, une jonction de type any retournera une valeur vraie si l'une au moins des valeurs de la jonction est vraie ; une jonction de type all renverra vrai si toutes les valeurs de la jonction sont vraies, et ainsi de suite. Les opérateurs |, ^ et & ne sont plus des opérateurs booléens binaires, mais des opérateurs infixés de jonctions ou même des constructeurs de jonctions :

1 | 2 | 3est la même chose que any(1..3).

my Junction $jour_semaine = any <lundi mardi mercredi
                            jeudi vendredi samedi dimanche>;
if $jour eq $jour_semaine {    # on suppose que $jour a été initialisé
    say "Rendez-vous $jour à 20 h pour dîner";
}

Dans cet exemple, l'opérateur eq est appelé avec chaque paire $jour_semaine, 'lundi', jour_semaine, 'mardi', etc. et le résultat est stocké dans une nouvelle jonction de type any. Dès que le résultat est connu (dans ce cas, dès que l'une des comparaisons a renvoyé True) l'exécution des autres comparaisons peut être interrompue par le compilateur.

Ce sont les jonctions qui permettent de comparer simplement une variable à plusieurs valeurs simultanément, comme cela a été abordé dansla première partie de ce tutoriel :

say "$_ est un nombre de Fibonacci" 
     for grep { $_ == any(<1 2 3 5 8 13>)}, 1..20;
     # Noter la virgule après le bloc du grep en Perl 6

Ce qui imprime bien :

1 est un nombre de Fibonacci
2 est un nombre de Fibonacci
3 est un nombre de Fibonacci
5 est un nombre de Fibonacci
8 est un nombre de Fibonacci
13 est un nombre de Fibonacci

En Perl 5 et dans la quasi-totalité des autres langages de programmation, il aurait fallu comparer la variable avec chacune des valeurs individuellement :

say "$_ est un nombre de Fibonacci" 
     for grep { $_ == 1 or $_ == 2 or $_ == 3 or $_ == 5 
     or $_ == 8 or $_ == 13} 1..20;
     # pas de virgule après le bloc du grep en Perl 5

On peut aussi utiliser une jonction sur un tableau calculé précédemment. Si nous avons calculé les premiers nombres de Fibonacci et les avons stockés dans le tableau @fib, la syntaxe suivante évite de coder une boucle imbriquée :

my @fib = <1 2 3 5 8 13>; # initialisation figurant le calcul de @fib
say "$_ est un nombre de Fibonacci" for grep { $_ == any(@fib)}, 1..20;

ce qui affiche la même chose que précédemment. En Perl 5, il aurait fallu une seconde boucle imbriquée, ou éventuellement stocker les nombres de Fibonacci dans un hachage (voire, pour les versions suffisamment récentes, utiliser l'opérateur smart match ~~, mais il vaut sans doute mieux éviter, dans la mesure où celui-ci est maintenant déprécié sur les dernières versions de Perl 5). À l'heure où nous écrivons, il est encore prématuré de faire un benchmark pour comparer les deux solutions. En théorie au moins, les différentes comparaisons peuvent être exécutées dans des threads différents tirant parti des processeurs multicore ou de plates-formes ayant des processeurs multiples. Nous ne pouvons dire si cette optimisation est implantée à ce jour.

Bien entendu, si nous ne voulions tester qu'un seul nombre de Fibonacci, nous n'avons plus besoin du grep :

my @fib = <1 2 3 5 8 13>;
say "Oui" if 8 == any(@fib); # Affiche "Oui"

Ceci fonctionne non seulement pour des opérateurs, mais aussi pour des fonctions.

if 2 == sqrt(4 | 9 | 16) {
    say "Oui"; # imprime Oui, puisque 2 est bien la racine de 4
}

Pour que cela soit possible, les jonctions ont une place légèrement à part dans la hiérarchie habituelle des types :

                      Mu
                    /    \
                   /      \
                 Any     Junction
               /  |  \
         Tous les autres types

Si vous voulez écrire une fonction qui prend en paramètre une jonction et ne lance pas automatiquement des threads, vous devez décrire le paramètre de la fonction comme soit Mu, soit Junction.

sub dump_yaml(Junction $stuff) {
    # nous espérons que Yaml peut représenter des jonctions ;-)
    ....
}

# Attention: comportement hypothétique non vérifié en Perl 6
my Junction $b = 3 | 2;
my $a = 2; 
say "Oui" if   $a != $b ;       # imprimerait Oui
say "Oui" if !($a == $b);       # n'imprime rien

my $mot = "oui";
my @negations = <non ne ni pas personne jamais nul>;
if $mot !eq any @negations {
    say "oui n'est pas une négation";
}

my $mot = 'oui';
my @negations = <non ne ni pas personne jamais nul>;
if $mot eq none @negations {
    say "oui n'est pas une négation";
}

Perl essaie d'être proche des langues naturelles, dans lesquelles on dit souvent des choses du genre : « le $résultat est $ceci ou $cela », plutôt que « le $résultat est $ceci ou le $résultat est cela ». La plupart des langages de programmation n'autorisent que la seconde forme (traduite dans le langage en question), ce qui donne une sensation de maladresse. Avec Perl 6, on peut aussi utiliser la première forme, plus intuitive.

Cela permet d'écrire très rapidement des comparaisons qui nécessiteraient des boucles explicites :

# code Perl 5:
my @items = get_data();
my $all_non_neg = 1;
for (@items){
    if ($_ < 0) {
        $all_non_neg = 0;
        last;
    }
}
if ($all_non_neg) { ... }

Ou, si vous connaissez le module List::MoreUtils :

use List::MoreUtils qw(all);
my @items = get_data;
if (all { $_ >= 0 } @items) { ...  }

En Perl 6, c'est on ne peut plus simple :

my @items = get_data();
if all(@items) >= 0 { ... }

1-3-1. Un mot d'avertissement▲

http://perlcabal.org/syn/S03.html#Junctive_operators

https://laurent-rosenfeld.developpez.com/tutoriels/perl/perl6/annexe-02/#L1-4-2

2-2-1. Opérateurs existants en Perl 5▲

my $c = my $d = my $e = 5;
print "Vrai\n" if $c == $d and $d == $e; # imprime Vrai
print "Vrai\n" if 5 < 7 and 7 < 9 and 9 < 14 and 14 < 17; # Vrai aussi

my $c = my $d = my $e = 5;
say "Vrai" if $c == $d == $e;       # syntaxe illégale en Perl 5
say "Vrai" if 5 < 7 < 9 < 14 < 17;  # les 2 lignes impriment aussi vrai

2-2-2. Nouveaux opérateurs▲

2-2-3. Smart match (comparaison intelligente)▲

http://perlcabal.org/syn/S03.html#Smart_matching

my ($x, $y);
$x := $y;
$y = 4;
say $x;             # imprime 4
if $x =:= $y {
    say '$x et $y sont des noms différents pour la même chose'
}

Perl 6 fait la distinction entre les contenants (containers) et les valeurs qui peuvent être stockées dans ces contenants.

Une variable scalaire ordinaire est un contenant et peut avoir des propriétés telles que des contraintes de type ou des contraintes d'accès (par exemple, elle peut être en lecture seule), et elle peut être aliassée à d'autres contenants.

Mettre une valeur dans un contenant s'appelle une affectation (assignment) et se fait avec l'opérateur = (comme en Perl 5). Créer un alias entre deux contenants revient à établir une liaison (binding) et se fait avec l'opérateur := ; on dira alors que les variables sont liées.

my @a = 1, 2, 3;
my Int $x = 4;
@a[0] := $x;     # @a[0] et $x sont maintenant la même variable
@a[0] = 'Foo';   # Erreur: 'Type check failed'

Les types tels que Int ou Str ne sont pas modifiables, ce qui veut dire que les objets de ces types ne peuvent être modifiés. Mais cela n'empêche pas de modifier les variables (c'est-à-dire les contenants) dans lesquelles ils sont stockés :

my $a = 1;
$a = 2;   # rien de surprenant ici

La liaison entre deux contenants peut être effectuée au moment de la compilation à l'aide de l'opérateur ::=.

Il est possible de vérifier si deux variables sont liées avec l'opérateur =:=.

L'importation et l'exportation de fonctions, de types et de variables se font par l'utilisation d'alias. Plutôt que de recourir à une magie d'alias implicite et parfois difficile à comprendre, Perl 6 offre un opérateur explicite simple.

http://perlcabal.org/syn/S03.html#Item_assignment_precedence

Les opérateurs numériques (+, -, /, *, **, %) restent tous inchangés.

Comme les opérateurs |, ^ et & servent désormais à construire des jonctions (§ 1), les opérateurs binaires n'ont plus la même syntaxe. Ils contiennent maintenant un préfixe de contexte : par exemple, le OU binaire s'écrit maintenant +| en contexte numérique (2), et ~^ est le complément sur une chaîne. Les opérateurs de décalage de bits ont changé de la même façon : le décalage à gauche (anciennement <<) devient +<.

L'opérateur de concaténation de chaîne est désormais ~ (le point . étant utilisé pour les invocations de méthodes).

Les opérateurs de tests sur les fichiers sont maintenant en notation par paire clef-valeur (objet de type Pair).La clef contient l'opérateur et la valeur le résultat du test. Par exemple, l'opérateur -e de Perl 5 est remplacé par :e (dans une paire clef-valeur :key<value>, :key renvoie vrai si la valeur est vraie). Si le nom du fichier n'est pas contenu dans $_, alors il peut être fourni avec l'opérateur de comparaison intelligente et utilisant la syntaxe : $filename.path ~~ :e.

L'opérateur de répétition xest maintenant disjoint en deux opérateurs distincts : x réplique les chaînes de caractères et xx les listes.

L'opérateur conditionnel ternaire précédemment appelé $condition ? $true : $false, s'appelle désormais $condition ?? $true !! $false.

Les opérateurs de comparaison peuvent s'enchaîner, si bien que l'on peut écrire :

if $a < $b < $c {...}

et obtenir exactement ce que l'on veut dire (même sens qu'en mathématiques).

De même pour des comparaisons lexicographiques :

say "Vrai" if 'abc' le 'bc' le 'efgh'; # imprime Vrai

Ce texte n'est pas un document de référence, mais il paraît utile de donner ici la précédence (priorité d'exécution) des différents opérateurs. Cela permet en outre de mentionner l'existence d'opérateurs que nous n'avons pas cités ici, mais qui pourront éventuellement intéresser le lecteur. De plus, cela sera utile pour une meilleure compréhension d'un prochain chapitre (§ 6, Créer ses propres opérateurs, et, plus précisément la section 6.2.1).

Le tableau suivant résume la précédence des opérateurs inclus dans Perl 6, classés depuis ceux ayant la précédence la plus forte vers ceux ayant la plus faible.

La colonne de gauche (A) donne l'associativité lorsqu'il y a plus de deux termes ayant la même précédence (voir aussi § 6.2.2) :

• G : associatif à gauche (par ex. : $c - $d - $e s'interprète comme ($c - $d) - $e) ;
• D : associatif à droite (par ex. : $c ** $d ** $e équivaut à $c ** ($d ** $e) ) ;
• N : chaînage d'opérateurs interdit ou n'ayant pas de sens (donc, illégal) ;
• C : chaînage (par ex. : $c < $d < $e équivaut à ($c < $d) and ($d < $e) ) ;
• X : création de liste (par exemple une jonction : 9|10|11 ou any(9, 10, 11) ) ;

Les opérateurs manipulent des données. Les métaopérateurs manipulent des opérateurs.

4-4-1. Les opérateurs de réduction▲

my @nombres = 1..5;
my $somme = [+] @nombres;       # 15:  1 + 2 + 3 + 4 + 5
my $produit = [*] @nombres;     # 120: 1 * 2 * 3 * 4 * 5

my $x = [<] @y;   # vrai si les éléments de @y sont triés par ordre ascendant
my $z = [>] @y;   # vrai si les éléments de @y sont triés par ordre descendant

4-4-2. Les hyperopérateurs▲

my @a = 1..5;
my @b = 6..10;
my @c = 5 <<*>> @b;
say @c;              # imprime 30 35 40 45 50
my @d = @a >>*<< @b;
say @d;              # imprime 6 14 24 36 50
# @d = 1*6, 2*7, 3*8, 4*9, 5*10

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

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

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

@x >>+=<< @y   # Même chose que @x = @x >>+<< @y

4-4-3. L'opérateur croix (cross)▲

my @a = 1, 2;
my @b = 3, 4;
my @c = @a X @b;  # (1,3), (1,4), (2,3), (2,4)

my @a = 3, 4;
my @b = 6, 8;
say @a X* @b;    # imprime 18 24 24 32

Certains de ces changements visent à un meilleur codage de Huffman, c'est-à-dire donner un nom court aux opérateurs souvent utilisés (comme le . pour les appels de méthodes) et un nom plus long aux opérateurs moins souvent utilisés (comme les opérateurs binaires, par exemple ~& pour le ET binaire pour les chaînes).

L'enchaînement des opérateurs de comparaison est une façon de rendre le langage plus naturel et de permettre des choses qui sont utilisées communément en notation mathématique.

Les métaopérateurs permettent une grande expressivité sur les listes.

http://perlcabal.org/syn/S03.html#Changes_to_Perl_5_operators

http://doc.perl6.org/language/operators

https://laurent-rosenfeld.developpez.com/tutoriels/perl/perl6/annexe-01/#L2

https://laurent-rosenfeld.developpez.com/tutoriels/perl/perl6/annexe-01/#L4

https://laurent-rosenfeld.developpez.com/tutoriels/perl/perl6/annexe-02/#L4

La paresse est une vertu pour le programmeur Perl 5. En Perl 6, même les listes sont paresseuses. (3)

En l'occurrence, le mot paresseux signifie que l'évaluation d'une liste est retardée au maximum. Si l'on écrit ce genre de code :

my @a := map BLOCK, @b;

le bloc n'est pas exécuté immédiatement. Ce n'est que quand on accède aux éléments de @a que le map exécute le bloc et fournit à @a les éléments nécessaires.

À noter l'utilisation de l'opérateur de liaison := au lieu de celui affectation. Affecter à un tableau peut conduire à une évaluation avide ou gourmande (à moins que le compilateur ne sache que la liste sera infinie ; les détails exacts de comment ce sera fait sont encore susceptibles de changer), mais l'opérateur de liaison ne le fait jamais.

La paresse permet de traiter des listes infinies. Tant que l'on n'applique pas un traitement à tous ses arguments, les listes infinies n'occupent en mémoire que l'espace requis pour stocker les éléments qui ont déjà été évalués.

Il y a cependant quelques pièges à éviter. Déterminer la longueur d'une liste ou la trier tue la paresse. Si la liste est infinie, ça va boucler indéfiniment, ou ça va échouer si la nature infinie de la liste peut être détectée.

D'une façon générale, toutes les conversions vers des scalaires (comme List.join) sont avides, c'est-à-dire non paresseuses.

La paresse empêche les calculs inutiles et peut donc améliorer considérablement les performances tout en conservant du code simple.

Quand on lit un fichier ligne à ligne en Perl 5, on évite généralement d'utiliser la syntaxe for (<HANDLE>), parce que cela a pour effet de lire l'ensemble du fichier en mémoire avant de commencer à itérer sur son contenu. Avec la paresse, ce n'est plus un problème :

my $file = open '/etc/passwd';
for $file.lines -> $line {
    say $line;
}

Comme file.lines est une liste paresseuse, les lignes ne sont lues depuis le disque qu'en cas de besoin (hormis, bien sûr, l'utilisation interne de mémoire tampon pour réduire le nombre d'appels système).

5-2-1. Gather/take▲

my @list := gather {
    while True {
        # calculs;
        take $result;
    }
}

my @list = gather {
    for 1..10 {
        do_some_computation($_);
    }
}

sub do_some_computation($x) {
    take $x * ($x + 1);
}
print " ", @list[$_] for 1..7; # imprime  6 12 20 30 42 56 72

# Liste infinie paresseuse :
my $list = lazy gather {
    for 1..Inf {
        do_some_computation($_);
    }
}

my @list = gather for 1..10 {
    do_some_computation($_);
}

5-2-2. Un exemple complet : parcours de deux arbres binaires▲

sub fringe ($tree) {
    multi sub fringey (Pair $node) { fringey $_ for $node.kv; }
    multi sub fringey ( Any $leaf) { take $leaf; }
    gather fringey $tree;
}
sub samefringe ($a, $b) { fringe($a) eqv fringe($b) }

5-2-3. Contrôler la paresse▲

my @list = eager map { $bloc_ayant_des_effets_de_bord }, @list;

my $ls = lazy { $calcul_long_et_coûteux };

En informatique, les problèmes peuvent pour la plupart être décrits comme des arbres de combinaisons possibles parmi lesquelles on cherche une solution. L'une des clefs pour construire un algorithme efficace est non seulement de trouver une manière efficace de trouver la solution, mais aussi d'être en mesure de ne construire que les parties intéressantes de l'arbre. C'est ce que font les algorithmes ou heuristiques de type branch and bound (séparation et évaluation) utilisés par exemple en recherche opérationnelle pour résoudre des problèmes de classe NP.

Les listes paresseuses permettent de définir cet arbre récursivement et de l'explorer pour trouver la solution : bien utilisées, elles ne construiront que les parties de l'arbre que vous avez réellement besoin d'utiliser.

D'une façon générale, la paresse rend la programmation plus facile parce qu'il n'y a pas besoin de savoir si le résultat d'un calcul sera vraiment utilisé : il suffit de le rendre paresseux et, s'il n'est en définitive pas utilisé, il ne sera simplement pas exécuté. Si l'on en a besoin, il sera exécuté au moment où c'est nécessaire, mais on n'aura rien perdu.

http://perlcabal.org/syn/S02.html#Lists

Les opérateurs sont des fonctions ayant des noms inhabituels et quelques propriétés supplémentaires telles que la précédence (priorité d'exécution) et l'associativité. Perl 6 utilise le plus souvent une notation dite infixée, du type terme opérateur terme, dans laquelle terme peut éventuellement être lui-même précédé d'un opérateur préfixé ou suivi d'opérateurs postfixés ou postcirconfixés.

Les noms des opérateurs ne se limitent pas à des caractères spéciaux, ils peuvent contenir à peu près n'importe quoi à l'exception des espaces blancs.

Le nom complet d'un opérateur est son type, suivi d'un caractère deux points (« : ») et d'une chaîne de caractères ou d'une liste de symboles. Par exemple infix:<+> est l'opérateur d'addition utilisé dans l'expression 1 + 2. Ou encore postcircumfix:<[ ]>, l'opérateur utilisé dans @array[0].

Vous en savez déjà assez pour définir un nouvel opérateur :

multi sub prefix:<%> (Int $x) {   # opérateur double
    2 *  $x;
}
say % 35; # imprime 70

Mais ce nouvel opérateur peut aussi s'appeler autrement :

multi sub prefix:<deux_fois> (Int $x) {
    2 *  $x;
}
say deux_fois 35; # imprime 70

De même, il est possible d'utiliser d'autres délimiteurs pour encadrer le nom de l'opérateur. Les différentes déclarations suivantes indiquent théoriquement toutes le même opérateur d'addition :

infix:<+>
infix:<<+>>
infix:«+»
infix:('+')
infix:("+")

Apparemment, seules les deux premières syntaxes étaient réellement implémentées dans la version de Rakudo Star utilisant la machine virtuelle Parrot à l'heure où nous écrivions la version initiale de ce document (fin 2014). Avec la machine virtuelle MoarVM en septembre 2015, cela fonctionne correctement :

multi sub prefix:«triple» (Int $x) {3 *  $x}
say triple 14;          # -> 42
multi sub prefix:('tiers') (Int $x) {$x / 3}
say tiers 126;          # -> 42

6-2-1. Précédence▲

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

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

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

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

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

6-2-2. Associativité▲

6-2-3. Notation postcirconfixée et circonfixée▲

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

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

6-2-4. Surcharger les opérateurs existants▲

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

6-2-5. Un exemple plus complet▲

use v6;

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

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

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

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

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

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

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

Permettre à l'utilisateur de déclarer de nouveaux opérateurs et de surcharger des opérateurs existants rend les types définis par l'utilisateur aussi puissants que les types internes. Si les opérateurs internes sont insuffisants, on peut les remplacer par d'autres, plus adaptés à la situation, sans pour autant à avoir à changer quoi que ce soit au compilateur.

Cela réduit aussi le fossé entre « utiliser un langage », et « étendre ou modifier le langage ».

http://perlcabal.org/syn/S06.html#Operator_overloading

https://laurent-rosenfeld.developpez.com/tutoriels/perl/perl6/annexe-02/#L5

Si l'aspect technique vous intéresse et si vous voulez comprendre comment Perl 6 parvient à mettre en œuvre ces surcharges d'opérateur et autres modifications de grammaires, consultez le site suivant: http://perlgeek.de/en/article/mutable-grammar-for-perl-6.

Appeler une fonction et lancer un programme Unix depuis la ligne de commande du shell se ressemblent beaucoup : il est possible d'utiliser des arguments positionnels, optionnels et nommés.

Il est possible d'en tirer parti, parce que Perl 6 peut analyser la ligne de commande à votre place en en faisant un appel de fonction. Le script est lancé normalement (c'est le moment où il récupère les arguments de la ligne de commande stockés dans @*ARGS) et la fonction MAIN est immédiatement appelée si elle existe, avec lesdits arguments.

Si la fonction MAIN ne peut être appelée parce que les arguments de la ligne de commande du shell ne concordent pas avec ses paramètres formels, le programme meurt en imprimant un message généré automatiquement rappelant la syntaxe d'appel.

Considérons par exemple le programme (pas très utile) suivant qui imprime le produit des deux nombres entiers qui lui sont passés en argument, et le double de l'entier passé en argument s'il n'y en a qu'un seul :

#!/usr/bin/perl6

sub MAIN ( Int :$nombre_1, Int :$nombre_2 = 2) {
    my $result = $nombre_1 * $nombre_2;
    say $result;
}

Essayons de l'exécuter avec différents arguments passés à la ligne de commande :

~ # appel correct: arguments nombre_1 et nombre_2 sont des Int
~ ./mult_ou_double.pl --nombre_1=7 --nombre_2=5
35

~ # correct: avec des arguments nommés, l'ordre importe peu
~ ./mult_ou_double.pl --nombre_2=7 --nombre_1=5
35

~ # correct (avec second argument remplacé par la valeur 2 par défaut)
~ ./mult_ou_double.pl --nombre_1=7
14

~ # incorrect: le nom de l'argument est inconnu
~ ./mult_ou_double.pl --nombre=7
Usage:
  mult_ou_double.pl [--nombre_1=<Int>] [--nombre_2=<Int>]

~ # incorrect: le second argument n'est pas un entier
~ ./mult_ou_double.pl --nombre_1=7 --nombre_2=5.5
Usage:
  mult_ou_double.pl [--nombre_1=<Int>] [--nombre_2=<Int>]

~ # incorrect: le second argument n'est pas numérique
~ ./mult_ou_double.pl --nombre_1=7 --nombre_2=string
Usage:
  mult_ou_double.pl [--nombre_1=<Int>] [--nombre_2=<Int>]

On constate que la signature de la fonction MAIN permet de valider les arguments passés au programme ou de les rejeter. À noter que cela marche aussi dans une fenêtre de commande Windows (mais les utilisateurs Windows utilisent plutôt rarement la ligne de commande). Si la validation des arguments échoue, la fonction USAGE est appelée, si elle existe, pour informer l'utilisateur de la syntaxe d'appel. Si la fonction USAGE n'existe pas, un message décrivant la syntaxe d'appel est généré à la compilation à partir de la signature de la fonction (ou des fonctions) MAIN, comme on peut le voir dans les trois derniers exemples ci-dessus.

La correspondance entre les options de la ligne de commande et la fonction se fait comme suit :

La syntaxe $x = $obj but false signifie que $x est une copie de l'objet, mais renvoie Bool::False dans un contexte booléen.

Donc, dans les cas simples (et même nettement moins simples), il n'est pas nécessaire de créer une fonction spécifique de traitement des arguments passés au programme, il suffit d'utiliser la signature de la fonction MAIN à cet effet.

Il est également possible de déclarer MAIN comme un ensemble de fonctions multis :

multi MAIN (Int $i) {...}   # mon_progr.pl 1
multi MAIN (Rat $i) {...}   # mon_progr.pl 1/2
multi MAIN (Num $i) {...}   # mon_progr.pl 1e6
multi MAIN (Str $i) {...}   # mon_progr.pl toto

Le compilateur sélectionnera la version de MAIN dont la signature correspond aux paramètres reçus, si possible.

La motivation semble évidente. Cela rend les choses simples plus faciles, les choses semblables semblables, et, bien souvent, permet de réduire le traitement de la ligne de commande à une seule ligne de code: la signature de la fonction MAIN.

7-3-1. Voir aussi▲

En Perl 5, le sigil est le caractère dit « de ponctuation » (en fait, généralement $, @, %, &, *) qui précède le nom d'une variable et donne son type. En Perl 6, on parle de twigil quand il y a deux caractères de ce type en tête d'une variable. Cela signifie généralement que la variable n'est pas « normale », mais qu'elle diffère d'une façon ou d'une autre ; par exemple, elle peut avoir une portée différente.

Nous avons déjà rencontré ces twigils à propos de la programmation objet : les attributs publics et privés des objets ont, respectivement les twigils . et !. Ce ne sont pas des variables normales, elles sont liées à self.

Le twigil ^ permet de supprimer un cas particulier de Perl 5. Pour pouvoir écrire :

# code Perl 5
sort { $a <=> $b } @array;

il faut que les variables spéciales $a et $b soient exemptées du pragma strict. Perl 6 propose le concept de paramètre positionnel autodéclaré nommé. Ce genre de paramètre utilise le twigil ^. Cela signifie que ce sont des paramètres positionnels du bloc courant qui n'ont pas besoin d'être déclarés dans la signature. Les variables sont alimentées par ordre lexicographique (pseudoalphabétique) :

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

Il est donc maintenant possible d'écrire :

  @list = sort { $^b <=> $^a }, @list; # virgule après le bloc
  # ou:
  @list = sort { $^toto <=> $^titi }, @list;

sans qu'il s'agisse de variables spéciales ou de cas particuliers. Par exemple :

#!/usr/bin/perl6

my @list = 1, 5, 6, 7, 4, 0, 67, 44;
my @sorted_list_desc = sort {$^toto <=> $^titi}, @list;
say @sorted_list_desc; # affiche : 67 44 7 6 5 4 1 0
say sort {$^titi <=> $^toto}, @list; # affiche 0 1 4 5 6 7 44 67

Et pour conserver la symétrie entre arguments positionnels et nommés, le twigil : fait la même chose pour les paramètres nommés, si bien que ces lignes sont à peu près équivalentes :

my $block = { say $:stuff };
# ou
my $sub   = sub (:$stuff) { say $stuff };

Le twigil ? représente les variables ou constantes qui sont connues au moment de la compilation. Par exemple, $?LINE représente la ligne de code courante (anciennement __LINE__) et $?DATA est le descripteur de fichier (file handle) attaché à la section DATA.

On peut accéder aux variables contextuelles grâce au twigil « * », si bien que les variables $*IN et $*OUT peuvent être modifiées dynamiquement.

Le signe < est un pseudotwigil utilisé dans une construction du genre $<capture>, représentant un raccourci pour $/<capture>, qui accède à l'objet reconnu après le succès d'une regex.

À la lecture du document perlvar de Perl 5, on constate qu'il y a beaucoup trop de variables spéciales, globales pour la plupart, affectant le fonctionnement des programmes de diverses manières.

Les twigils essaient de ramener un peu d'ordre dans ces variables spéciales et permettent aussi d'éliminer le besoin de cas particuliers. Dans le cas des attributs d'objets, elles permettent de raccourcir la notation self.var en $.var (ou @.var, etc.).

L'un dans l'autre, le « bruit de ponctuation » augmente certes quelque peu, mais cela rend les programmes nettement plus cohérents et plus lisibles.

Les énumérations sont des bestioles assez versatiles. Elles sont des classes de bas niveau qui consistent en une liste de constantes, habituellement des entiers ou des chaînes de caractères (mais ça peut être des types arbitraires). Elles permettent d'employer un ensemble de symboles pour représenter un ensemble de valeurs. Chaque association d'une énumération est une paire de constantes déclarée avec le mot-clef enum et de type Enum. Chaque enum associe une clef d'enum avec une valeur d'enum. Sémantiquement, une enum est donc en quelque sorte un hachage de constantes.

Par exemple, la ligne de code suivante :

enum E <a b c>;

est essentiellement du sucre syntaxique pour :

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

Lorsque les valeurs ne sont pas spécifiées, elles prennent les valeurs 0, 1, 2, etc.

Pour spécifier des valeurs particulières, il faut par exemple employer la syntaxe suivante :

my enum chiffres_romains (I => 1,   V => 5,
                X => 10,  L => 50,
                C => 100, D => 500,
                M => 1000);
say chiffres_romains.enums.kv; 
         # imprime: I 1 V 5 X 10 L 50 C 100 D 500 M 1000

9-2-1. Une enum booléenne▲

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

say ouinon.enums.keys;                # imprime non oui
say ouinon.enums.values;              # imprime 0 1
say ouinon.enums.kv;                  # imprime non 0 oui 1
say ouinon.enums.invert;              # imprime 0 => "non" 1 => "oui"

our enum Bool does Boolean <False True>;

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

enum Jour ('lun', 'mar', 'mer', 'jeu', 'ven', 'sam', 'dim');
my $x = "aujourd'hui" but Jour::mar;
say $x;                          # imprime aujourd'hui
say $x.Jour;                      # imprime mar

my $x = "aujourd'hui" but Jour(jeu);
say $x;                          # imprime aujourd'hui
say $x.Jour;                     # imprime jeu

enum Hackers (:Larry<Perl>, :Guido<Python>, :Paul<Lisp>);
say Larry.pair;                  # imprime : "Larry" => "Perl"
# ou encore avec cette autre syntaxe :
my enum chiffres_romains (I => 1,   V => 5,
                X => 10,  L => 50,
                C => 100, D => 500,
                M => 1000);
say chiffres_romains.enums;
# imprime: ("I" => 1, "V" => 5, "X" => 10, "L" => 50, "C" => 100, "D" => 500, "M" => 1000).hash

if $today ~~ Day::Fri {
    say "Dieu merci, c'est vendredi!"
}
if $today.does(Fri) { ... }

Les énumérations remplacent à la fois la « magie » associée aux variables « tainted » et la sémantique particulière de l'expression « 0 but true » de Perl 5, interprétée comme un zéro en contexte numérique, mais comme vrai en contexte booléen, sans que cela ne provoque d'avertissement. Elles permettent aussi de créer un type booléen.

Les énumérations offrent aussi la puissance et la flexibilité d'associer des métadonnées arbitraires utiles pour le débogage et le traçage.

9-3-1. Voir aussi▲

Bien que Perl 5 soit depuis plus d'une dizaine d'années l'un des meilleurs langages pour gérer l'Unicode (avec de solides améliorations à presque chaque nouvelle version), le modèle Unicode de Perl 5 souffre d'une sérieuse faiblesse : il utilise le même type pour les données binaires et textuelles. Par exemple, si un programme lit 512 octets sur un socket réseau, il s'agit certainement d'une chaîne d'octets. Cependant, en Perl 5, si on appelle la fonction uc sur cette chaîne d'octets, celle-ci sera traitée comme du texte. Il est recommandé de commencer par décoder la chaîne d'octets, mais quand une fonction reçoit une telle chaîne en argument, elle ne peut savoir à coup sûr si celle-ci a été encodée ou non, autrement dit si elle doit être traitée comme un objet binaire ou comme du texte.

Perl 6 offre au contraire le type buf, qui est une simple collection d'octets, et le type Str, qui est une collection de caractères logiques.

L'expression caractère logique reste cependant assez floue. Pour être plus précis, un objet de type Str peut se concevoir à différents niveaux : octet (Byte), point de code (ou Codepoint, tous les signes auxquels le Consortium Unicode attribue un nombre est un point de code), un graphème (Grapheme, les choses qui ont visuellement l'apparence d'un caractère) et les Charlingua (caractères définis par le langage).

Par exemple la chaîne contenant les octets hexadécimaux 61 cc 80 contient (à l'évidence) trois octets, mais peut aussi être considérée comme composée de deux points de code appelés LATIN SMALL LETTER A (U+0041, lettre minuscule latine « a ») et COMBINING GRAVE ACCENT (U+0300, accent grave, diacritique), ou encore comme le graphème « à ».

Il en résulte qu'il n'est simplement pas possible de demander la taille d'une chaîne. Il faut spécifier le type de taille voulu :

$str.bytes;
$str.codes;
$str.graphs;

Il existe également une méthode nommée chars, qui renvoie la longueur de la chaîne dans le mode Unicode courant (ce mode peut être sélectionné à l'aide d'un pragma, par exemple use bytes;) et donne par défaut le nombre de graphèmes.

En Perl 5, il pouvait occasionnellement arriver de concaténer accidentellement des chaînes d'octets et de caractères. En cas de problème de ce genre en Perl 6, il est facile d'identifier où et quand le problème se produit en surchargeant l'opérateur de concaténation :

sub GLOBAL::infix:<~> is deep (Str $a, buf $b)|(buf $b, Str $a) {
   die "Can't concatenate text string «"
       ~ $a.encode("UTF-8")
         "» with byte string «$b»\n";
}

10-1-1. Encodage et décodage▲

my $handle = open($filename, :r, :encoding<UTF-8>);

10-1-2. Regex et Unicode▲

10-1-3. Motivation▲

10-1-4. Voir aussi▲

11-2-1. La notion de bloc▲

class Block is Code { }

my $block = { uc $_; };
say $block.WHAT;            # imprime : Block
say $block('hello');        # imprime : HELLO

my $add = -> $a, $b { $a + $b };
say $add(38, 4);            # imprime : 42

my $swap = <-> $a, $b { ($a, $b) = ($b, $a) };
my ($a, $b) = (2, 4);
$swap($a, $b);
say $a;                      # imprime 4

sub fonction {
    for 1..10 -> $x {
        say $x;
        return if $x == 5;
    }
    say 15;
}
fonction(); # imprime les chiffres de 1 à 5, mais n'imprime pas 15

11-2-2. Portée lexicale▲

use v6;

my @liste = 1..10;
while my $i = shift @liste {
    last if $i > 4;
    say "La valeur du compteur dans la boucle est $i";
}
say "Valeur du compteur hors de la boucle: $i";

perl6 count.pl
La valeur du compteur dans la boucle est 1
La valeur du compteur dans la boucle est 2
La valeur du compteur dans la boucle est 3
La valeur du compteur dans la boucle est 4
Valeur du compteur hors de la boucle: 5

for 1..5 -> $j {
    say "La valeur du compteur dans la boucle est $j";
}
say "Valeur du compteur hors de la boucle: $j"; # ERREUR

===SORRY!=== Error while compiling count.pl
Variable '$j' is not declared
at count.pl:7

if calc() -> $result {
    # $result est accessible ici
}
# $result non visible ici

my $x = .... ;
        ^^^^^
        $x est visible ici en Perl 6
        mais pas en Perl 5

my $x = $x;           # ne marche pas en Perl 6

11-2-3. Portée dynamique▲

11-2-4. Variables de contexte▲

# Code Perl 5 erroné
sub DESTROY { eval { 1 }; }

eval {
    my $x = bless {};
    die "Mort\n";
};
print $@ if $@;         # ERREUR: n'imprime rien

11-2-5. Les pseudopaquetages▲

my $x = 3;
{
    my $x = 10;
    say $x;             # imprime 10
    say $OUTER::x;      # imprime 3
    say OUTER::<$x>     # imprime 3
}

Il est généralement admis que les variables globales sont dangereuses et à la source de nombreux problèmes. Il reste parfois tentant, en Perl 5, de déclarer des variables globales, notamment pour des tableaux ou hachages servant de paramétrage général à une application. Nous avons à notre disposition les ressources pour mettre en œuvre un meilleur mécanisme de contrôle de la portée des variables. Cela permet de n'utiliser des variables globales que pour les données qui sont intrinsèquement globales (comme %*ENV et $*PID).

Les règles régissant la portée lexicale dans les blocs ont été fortement simplifiées.

Voici une citation du document Perlsyn de Perl 5 :

Note : le comportement d'une instruction my, state ou our modifiée par un modificateur conditionnel ou une construction de boucle (par exemple my $x if ...) est indéfini. La valeur de la variable peut être undef, la valeur précédemment affectée ou n'importe quoi d'autre. Ne dépendez pas d'un comportement particulier. Les prochaines versions de Perl feront peut-être quelque chose de différent que celle que vous utilisez actuellement.

Nous ne voulons pas d'un comportement aussi compliqué en Perl 6.

S04 discute de la portée des blocs : http://perlcabal.org/syn/S04.html.

S02 énumère tous les pseudo-paquetages et explique la portée contextuelle :

http://perlcabal.org/syn/S02.html#Names.