Tour d'horizon du nouveau langage Perl 6

Il existe trois principales sortes de variables, qui se distinguent par le sigil précédant l'identifiant proprement dit :

- le sigil « $ » indique une variable scalaire, c'est-à-dire une variable ne contenant qu'une seule valeur (par exemple une valeur numérique, une chaîne de caractères, un objet ou une référence vers une autre entité) ;

- le sigil « @ » désigne une variable de tableau, c'est-à-dire une liste de valeurs indexées par des entiers ;

- le sigil « % » dénote une table de hachage, qui est définie comme un ensemble de paires clef-valeur.

On accède aux éléments d'un tableau avec l'opérateur […] et à ceux d'un hachage avec {…}. Contrairement à Perl 5, une variable de tableau ou de hachage conserve son sigil d'origine quand on accède à ses éléments individuels :

> my @tableau = 1, 2, 4, 6;
[1 2 4 6]
> say @tableau[2];
4
> my %hachage = jan => 1, fév => 2, mar => 3;
fév => 2, jan => 1, mar => 3
> say %hachage{"fév"};
2

Nous avons vu que le mot-clef my sert à déclarer une variable. Plus précisément, il introduit une variable lexicale, c'est-à-dire une variable dont la portée est limitée au bloc de code dans lequel elle se trouve. Un bloc de code est, en simplifiant un peu, un fragment de code délimité par des accolades ouvrantes et fermantes servant à structurer le code. Une variable lexicale est visible et utilisable entre l'endroit où elle est déclarée avec le my et l'accolade fermant le bloc où se trouve la déclaration. Si la déclaration a lieu à l'extérieur de tout bloc, alors la variable est globale au script (ce qui n'est généralement pas conseillé).

{
    my Str $var = "texte";
    say $var;   # affiche "texte"
}
say $var; # ERREUR: $var n'est plus accessible

On peut aussi avoir deux variables de même nom ayant des valeurs différentes selon la portée dans laquelle elles se trouvent :

my Int var = 42;
{
    my Str $var = "texte";
    say $var;   # affiche "texte"
}
say $var;       # -> 42

Ces exemples sont un peu artificiels à ce stade, mais cette possibilité s'avérera très utile quand nous utiliserons des blocs décrivant des boucles ou le corps de fonctions.

Une variable peut être déclarée avec un type imposant des contraintes sur ses valeurs possibles :

my Int $c;
$c = 4;        # tout va bien, $c vaut 4
say $c.WHAT    # (Int)
$c = 4.2;      # ERREUR : Type check failed in assignment to $c...

Mais la déclaration n'est pas nécessaire et Perl 6 détermine dans ce cas lui-même le type de la donnée dans la mesure du possible :

my $d = 4.2;   # Pourrait aussi s'écrire : my $d = Rat.new(42, 10);
say $d.WHAT;                           # (Rat)
say '$d = ', $d.numerator, " / ", 
    $d.denominator;                    # affiche : $d = 21 / 5

On dit que Perl 6 est typé de façon « graduelle » : il autorise aussi bien un typage statique (comme C ou Java) qu'un typage dynamique (comme Perl 5, Ruby ou Python). Le meilleur de deux mondes, en quelque sorte. En fait, les variables $c et $d ci-dessus sont assimilables à des objets, respectivement de type Int et Rat, ce qui explique la possibilité d'invoquer sur eux les méthodes .WHAT ou .numerator. Pour les types les plus courants, il n'est souvent pas nécessaire d'invoquer le constructeur .new pour les obtenir. Ainsi, il existe plusieurs façons de créer des objets de type complexe :

my $z1 = 5 + 3i;
say $z1.WHAT;                   # (Complex)
my $z2 = Complex.new(4, 9);     # 4+9i
my Complex $z3 = 2 + 5i;
say $z1 + $z2 + $z3;            # affiche : 11+17i

L'utilisation d'une simple affectation est suffisante pour créer un objet du type voulu, mais les deux syntaxes utilisant explicitement le type Complex sont un peu plus sûres, car elles vérifient le type du littéral affecté à la variable. De même, considérons des objets de type Date :

my $d = Date.new(2015, 12, 24); # Veille de Noël : 2015-12-24
say $d.year;                    # 2015
say $d.month;                   # 12
say $d.day;                     # 24
say $d.day-of-week;             # 4  (donc, jeudi)
my $n = Date.new('2015-12-31'); # Saint-Sylvestre
say $n > $d;                    # True
say $n - $d;                    # 7 (delta 7 jours)
say $n + 1;                     # 2016-01-01
say 1+$n.later(:2months);       # 2016-03-01

Remarquez au passage combien la manipulation des dates devient facile et intuitive. C'est cela aussi la modernité de Perl 6. Ici, la syntaxe utilisant le constructeur new était nécessaire parce que sans elle, le programme ne pourrait reconnaître une date et effectuerait simplement une double soustraction entre entiers :

> my $d = 2015-12-25;  # Non, ce n'est pas Noël
1978

Les variables scalaires, introduites par le sigil $, ne contiennent qu'un seul élément (mais cet élément peut lui-même être composite, par exemple si c'est un objet comme nous venons de le voir dans les exemples ci-dessus). Les variables scalaires contiennent souvent des chaînes de caractères ou des nombres.

3-4-1. Chaînes de caractères▲

my $user = 'Laurent';
say "Bonjour, $user !";    # Bonjour Laurent !
say 'Bonjour, $user !';    # Bonjour $user !

say "Hello " ~ "World !";   # Hello World !

my $nom = "Charlie";
say flip $nom;  # eilrahC (syntaxe fonctionnelle)
say $nom.flip;  # eilrahC (syntaxe de méthode)
say uc $nom;    # CHARLIE
say $nom.uc;    # idem
say $nom.chars; # 7 (nombre de caractères)
say substr $nom, 2, 3; # arl (sous-chaîne)
say "Je suis " ~ $nom; # Je suis Charlie (concaténation)

> say flip "Charlie".substr(2, 3).uc
LRA

3-4-2. Données numériques▲

say 2.sqrt.WHAT; # (Num)
say 5.log.WHAT;  # (Num)
say 1e17.WHAT;   # (Num)

say 19.is-prime;  # True (19 est premier)
say 4.7.nude;     # (47 10), c'est-à-dire 47/10

subset Impair of Int where { $_ % 2 } # non divisibles par 2
# Impair est maintenant un sous-type
my Impair $x = 3;                     # OK
my Impair $y = 2;                     # erreur de type

Les tableaux sont des listes contenant des valeurs multiples. Les valeurs n'ont pas besoin d'être du même type (on peut par exemple mélanger des chaînes et des nombres), mais c'est souvent une bonne idée qu'elles le soient dans la mesure où les éléments d'un tableau doivent en principe avoir une certaine cohérence sémantique. On accède aux valeurs individuelles d'un tableau à l'aide d'indices qui sont des nombres entiers, le premier élément d'un tableau portant l'indice 0.

my @nombres_shadoks = ['GA', 'BU', 'ZO', 'MEU'];
say @nombres_shadoks[1];     # imprime: BU

Si les éléments d'un tableau sont des chaînes de caractères sans espace, on peut utiliser un opérateur de citation de liste <...> pour écrire plus simplement, sans guillemets, apostrophes, ni virgules :

> my @nombres_shadoks = <GA BU ZO MEU>;
[GA BU ZO MEU]
> say @nombres_shadoks.elems; # nombre d'éléments
4
> my $dernier = pop @nombres_shadoks;
MEU
> say @nombres_shadoks;
[GA BU ZO]
> say elems @nombres_shadoks; # nombre d'éléments
3
> say "Les shadoks ont perdu leur dernier chiffre: $dernier";
Les shadoks ont perdu leur dernier chiffre: MEU
> push @nombres_shadoks, $dernier;
[GA BU ZO MEU]

La fonction pop retire le dernier élément du tableau et le renvoie ; la fonction push ajoute un (ou plusieurs) élément(s) à la fin d'un tableau. On aurait aussi pu utiliser une syntaxe de méthode :

> my $dernier = @nombres_shadoks.pop
MEU
> say @nombres_shadoks
[GA BU ZO]
> @nombres_shadoks.push($dernier);
[GA BU ZO MEU]

La fonction splice(a, n) retire n élément(s) d'un tableau à partir de la position a et les renvoie :

> my @nombres_shadoks = <GA BU ZO MEU>;
[GA BU ZO MEU]
> my @elem_1_2 = splice @nombres_shadoks, 1, 2;
[BU ZO]

Mais si l'on désire récupérer collectivement plusieurs éléments d'un tableau sans modifier le tableau, on peut utiliser une syntaxe de tranches de tableaux :

my @nombres_shadoks = <GA BU ZO MEU>;
say @nombres_shadoks[0..2];  # (GA BU ZO)

Il existe de nombreuses autres fonctions ou méthodes utilisables, fournies notamment par les classes internes Array et List de Perl.

Les tableaux peuvent être multidimensionnels. On peut accéder aux éléments d'un tableau multidimensionnel en séparant les indices par un « ; » :

my $prem-rang_deux-col = @tableau[0;1];

Un hachage est un ensemble de paires clef-valeur. L'idée générale est la même que celle des dictionnaires ou maps dans d'autres langages.

> my %capitales = ("Italie", "Rome", "Allemagne", "Berlin", "Espagne", "Madrid");
Allemagne => Berlin, Espagne => Madrid, Italie => Rome

On peut rendre le code plus concis avec une syntaxe de liste :

> my %capitales = <Italie Rome Allemagne Berlin Espagne Madrid>;
Allemagne => Berlin, Espagne => Madrid, Italie => Rome

et plus clair en utilisant l'opérateur de construction de paires => dès l'initialisation :

my %capitales = (Italie => "Rome", Allemagne => "Berlin", Espagne => "Madrid");

L'opérateur => a essentiellement le même rôle qu'une virgule, mais elle rend l'intention plus claire et dispense de mettre la clef entre guillemets.

On peut ajouter un nouvel élément au hachage par une affectation avec une nouvelle clef :

%capitales{"France"} = "Paris";

Ou :

%capitales<France> = "Paris";

La méthode push permet également d'ajouter une nouvelle paire au hachage :

push %capitales, (Danemark => "Copenhague");
%capitales.push: (USA => "Washington");
say %capitales.elems ;   # 6 (nombre de paires)

Les méthodes kv, keys et values renvoient respectivement des listes de paires, de clefs et de valeurs :

> say %capitales.kv
(France Paris Allemagne Berlin Italie Rome USA Washington Danemark Copenhague Espagne Madrid)
> say %capitales.keys;
(France Allemagne Italie USA Danemark Espagne)
> say %capitales.values;
(Paris Berlin Rome Washington Copenhague Madrid)

Notons qu'un hachage stocke et restitue les paires dans un ordre apparemment aléatoire (indépendant de celui dans lequel elles ont été créées), mais les trois méthodes renvoient les éléments dans un ordre consistant.

Le tableau ci-dessous résume les opérateurs les plus communs, par ordre de précédence descendante (de la priorité la plus forte à la plus faible) :

Nous verrons plus loin qu'il est facile de construire ses propres opérateurs.

Les opérateurs de comparaison logique peuvent être chaînés comme en arithmétique, ce qui peut simplifier notablement l'écriture :

say "Valeurs dans l'ordre" if $u < $v < $x < $y < $z;
# équivaut à : ... if $u < $v and $v < $x and $x < $y ...
# ou à : ... if ($u < $v) and ($v < $x) and ...

De même, les jonctions permettent d'écrire des comparaisons concises de ce style :

my $x = 7;
say "Trouvé" if $x == 4|6|9|7|15; # -> Trouvé
# Peut aussi s'écrire :
say "Trouvé" if $x == any <4 6 9 7 15>;
# équivaut à : ... if ($x == 4) or ($x == 6) or ...

Les opérateurs travaillent sur des données, les métaopérateurs travaillent sur des opérateurs et permettent en quelque sorte de créer de nouveaux opérateurs.

Le métaopérateur de réduction […] permet de transformer un opérateur infixé associatif en un opérateur de liste renvoyant un scalaire :

> say [+] 1, 2, 3, 4;
10

Ici, tout se passe comme si on avait placé l'opérateur + entre chaque élément de la liste, comme si on avait écrit :

> say 1 + 2 + 3 + 4;
10

On peut de même calculer très facilement la factorielle de 10 en modifiant l'opérateur de multiplication :

my $fact10 = [*] 1..10;   # -> 3628800

Il existe d'autres métaopérateurs. Par exemple, le métaopérateur X renvoie un produit cartésien entre deux ou plusieurs listes :

> <a b c> X 1, 2;
((a 1) (a 2) (b 1) (b 2) (c 1) (c 2))

Un hyperopérateur applique une opération à chaque membre d'une liste ou de plusieurs listes et renvoie une nouvelle liste. Ici, chaque élément de la liste est multiplié par 5 :

> my @a = 6..10;
[6 7 8 9 10]
> say  5 «*» @a;
[30 35 40 45 50]

À noter que cet hyperopérateur utilise en principe les guillemets français «...», mais vous pouvez utiliser les chevrons ASCII <<...>> si votre éditeur ne vous permet pas d'écrire facilement ces guillemets français.

Avec deux ou plusieurs listes, l'hyperopérateur permet d'effectuer des opérations membre à membre sur les listes. Voici par exemple une concaténation membre à membre entre trois listes :

> my @x = ('a'..'e') «~» (3..7)  «~» ('v'..'z');
[a3v b4w c5x d6y e7z]

Les métaopérateurs et hyperopérateurs créent de nouveaux opérateurs en modifiant la sémantique d'opérateurs existants. Nous verrons plus loin qu'il est possible de créer facilement des opérateurs entièrement nouveaux. Tout cela tend à rendre le langage intrinsèquement malléable et extensible.

Pour assimiler un nouveau langage, rien ne vaut la pratique. Voici donc quelques exercices vous permettant de tester votre acquisition de connaissances.

• Exercice 1 : la fonction interne lcm renvoie le plus petit multiple commun (PPMC) entre deux nombres. Écrire un programme qui affiche le plus petit nombre positif divisible par tous les nombres de 1 à 20.
• Exercice 2 : écrire un programme qui calcule la somme des chiffres du nombre factorielle de 100 ;
• Exercice 3 : trouver la différence entre le carré de la somme des 100 premiers entiers naturels et la somme des carrés des 100 premiers entiers.

Nous n'avons pas encore étudié les conditions (if, etc.), ni les boucles (for, while, etc.), ni les fonctions. Il faut donc trouver dans ce que nous avons déjà appris d'autres solutions pour résoudre ces problèmes. Un indice : relisez tout le chapitre sur les opérateurs. Nous ne relèverons pas les copies, mais essayez vraiment de faire ces exercices.

Lorsque, au début de mes études d'informatique, j'ai dû faire ce genre d'exercices dans le langage de programmation choisi à l'époque par mes enseignants (Pascal ou C, par exemple), je m'attendais à devoir écrire quelques dizaines de lignes de code pour chacun d'entre eux. Ici, en Perl 6 et avec un modèle de programmation issu de la programmation fonctionnelle, chacun peut se faire en une seule petite ligne de code. Voilà notamment ce que nous voulons dire quand nous disons que Perl 6 est un langage puissant et expressif.

Vous trouverez des solutions à ces exercices dans l'encadré plus loin.

La condition if / else est classique. Sa seule particularité est que, contrairement à beaucoup de langages, elle ne nécessite pas de parenthèses autour de la condition :

my $âge = 19;
if $âge >= 18 {
    say "Vous êtes un adulte."
} else {
    say "Vous êtes un jeune."
}

À noter que le point-virgule n'est pas nécessaire avant une accolade fermant un bloc.

On peut également tester successivement plusieurs conditions avec des clauses elsif :

if $âge < 12 {
    say "Enfant"
} elsif $âge < 18 {
    say "Adolescent" 
} else {
    say "Adulte"
}

Une condition if peut également se placer après l'instruction (on parle alors d'instruction modifiée) :

> say "Bienvenue sur ce site" if $âge >= 18;
Bienvenue sur ce site

Cette syntaxe est concise et pratique, mais n'autorise pas de clause else ou elsif.

La condition unless inverse la condition :

say  "Désolé : réservé aux adultes !" unless $âge >= 18;
# équivalent à :
say  "Désolé : réservé aux adultes !" if not $âge >= 18;

La construction given … when correspond au switch d'autres langages, mais permet une formulation beaucoup plus riche et variée des conditions :

my Int $âge = 18;
given $âge {
    when *..^0 { say "âge négatif ? Hum..." };
    when 0..2  { say "Bébé" };
    when 3..12 { say "Enfant" };
    when *..17 { say "Adolescent" };
    when   18  { say "tout jeune adulte" };
    default    { say "Adulte"}
}

Dès que l'une des conditions est satisfaite, les conditions suivantes ne sont pas évaluées. La condition *..17, c'est-à-dire compris entre 0 et 17, est donc ici correcte et en fait équivalente à 13..17 puisque l'on n'arrive à cette condition que si les trois conditions précédentes ont échoué (ce qui ne veut pas dire qu'il soit recommandé d'écrire une telle bizarrerie contre-intuitive, donnée ici à seul titre d'exemple).

On peut inviter le programme à continuer l'évaluation des conditions suivantes même si une condition est satisfaite avec une instruction proceed :

my $var = 42;
given $var {
    when 0..50 { say 'Compris entre 0 et 50'; proceed };
    when Int   { say "Un entier"; proceed};
    when /4/   { say "Contient le chiffre 4"; proceed };
    when not .is-prime { say "Non premier";   proceed };
    when 42    { say "réponse à la Grande Question" }
}

Ici, grâce aux instructions proceed, chacun des cinq messages est affiché l'un après l'autre puisque toutes les conditions sont successivement satisfaites.

L'opérateur ternaire, issu du langage C, utilise ?? et !! :

> my ($x, $y) = (1, 2);
(1 2)
> say "Max = ", $x > $y ?? $x !! $y;
Max = 2

On peut enchaîner plusieurs de ces opérateurs :

my Int $âge = 18;
say $âge <= 2 ?? "Bébé" 
   !! $âge <= 12 ?? "Enfant" 
   !! $âge < 18 ?? "Ado" 
   !! $âge == 18 ?? "Jeune adulte" 
   !! "Adulte";

ce qui imprime « Jeune adulte ».

> say [lcm] 1..20;
232792560

> say [+] split '', [*] 2..100;
648

say ([+] 1..100)**2 - [+] (1..100) «**» 2; 
25164150

En Perl 6, la boucle la plus commune est la boucle for, qui itère sur une liste de valeurs ou les éléments d'un tableau et dont la syntaxe la plus commune est la suivante :

> my @tableau = [0..10];
[0 1 2 3 4 5 6 7 8 9 10]
> for @tableau -> $val { print $val * 2, " "};
0 2 4 6 8 10 12 14 16 18 20 >

Cette construction s'appelle un « bloc pointu ». Ici, la variable $val est un alias en lecture seule sur les valeurs successives du tableau ; elle n'a pas besoin d'être prédéclarée et sa portée est naturellement limitée au bloc d'instructions de la boucle for. Le lecteur féru de programmation fonctionnelle aura peut-être reconnu dans cette construction de « bloc pointu » à la fois une lambda et une fermeture anonyme.

La boucle for ci-dessus itère directement sur les éléments du tableau, ce qui correspond au besoin le plus fréquent. Si l'on a besoin d'itérer sur les indices, il suffit de créer à la volée une liste des indices à l'aide de l'opérateur intervalle .. et de la fonction ou méthode end (retournant l'indice du dernier élément d'un tableau) et d'itérer sur cette liste :

my @mois = <none jan fév mar avr mai jun>;
for 1..end @mois -> $num { say "$num \t @mois[$num]" };
# ou: for 1..@mois.end  -> ...

On peut également utiliser les itérateurs de listes du langage, par exemple keys pour récupérer la liste d'indices :

my @nombres = <zéro un deux trois quatre cinq>;
for @nombres.keys -> $indice  { say "$indice \t @nombres[$indice]" };

ou kv pour récupérer à la fois les indices et les éléments correspondants :

for @nombres.kv -> $indice, $nombre  { say "$indice \t $nombre" };

Si l'on a besoin de modifier les valeurs du tableau, il faut un alias en lecture et écriture, ce qui se fait à l'aide d'un bloc « doublement pointu » :

my @tableau = [0..10];
for @tableau <-> $val { $val *= 3 }
say @tableau;  # affiche [0 3 6 ... 30]

Une syntaxe d'expression modifiée est également possible :

> print $_ * 2, " " for [0..10];
0 2 4 6 8 10 12 14 16 18 20 >

Une boucle for est un itérateur et peut donc travailler de façon « paresseuse » (c'est-à-dire qu'elle ne traite les éléments qu'au fur et à mesure des besoins), même sur une liste « infinie ». Employer une boucle for est donc une façon idiomatique et performante d'itérer sur les lignes d'un fichier :

for "fichier.txt".IO.lines -> $ligne {
    say $ligne unless $ligne ~~ /^'#'/ 
}

La boucle while ressemble à celle des autres langages communs et exécute la boucle tant que la condition est vraie, si ce n'est que les parenthèses ne sont pas nécessaires autour de la condition :

> my $var = 0;
0
> while $var < 5 { print 3 * ++$var, " ";}
3 6 9 12 15 >

Une boucle until exécute le bloc de la boucle tant que la condition est fausse. Voici un exemple utilisant une syntaxe d'instruction modifiée :

my $x = 0;
print $x++ until $x > 5; # imprime 012345

Vous pouvez enfin utiliser une boucle loop, qui correspond à la boucle for du langage C et des langages apparentés :

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

Cette syntaxe permet de construire des boucles complexes, mais il est rare d'avoir besoin de ce genre de boucle en Perl 6 : la boucle for de Perl 6 est généralement bien plus pratique. C'est la seule construction de boucle pour laquelle les parenthèses restent nécessaires autour des conditions/initialisations. Sa seule utilisation fréquente est la façon idiomatique d'écrire une boucle infinie :

loop {…}

Les instructions next et last permettent, respectivement, de recommencer à l'itération suivante et de sortir immédiatement d'une boucle for, while ou autre :

for 1..20 -> $i { 
    next if 3 < $i <= 7;
    last if $i == 10;
    print "$i "; 
}   # imprime 1 2 3 8 9

La fonction ci-dessus ne prend pas de paramètres en entrée et ne renvoie pas de valeurs de retour, ce qui limite quelque peu son utilité. La plupart des fonctions utiles ont besoin de données en entrée, qui leur sont fournies sous la forme d'arguments. Voici une fonction analogue avec le passage d'un argument :

saluer("Maître");   # imprime "Bonjour Maître."
sub saluer ($titre) {
     say "Bonjour $titre.";
}

6-1-1. Nombre d'arguments d'une fonction▲

my Int $valeur = 5;
ajoute-deux($valeur);
say $valeur; # -> 7 
sub ajoute-deux (Int $x is rw) { $x += 2}

6-1-2. Type des arguments▲

sub multiplie (Int $x, Int $y) { 
    say "Produit = ", $x * $y 
}
multiplie(3, 4); # -> Produit = 12

6-1-3. Paramètres positionnels▲

multiplie 3, 4;  # -> Produit = 12

6-1-4. Paramètres nommés▲

sub divise (Numeric :$dividende, Numeric :$diviseur) { 
    say $dividende/$diviseur 
}
divise(dividende => 12, diviseur => 4);  # -> 3
divise diviseur => 4, dividende => 12 ;  # idem

Il est possible de définir avec le mot-clef multi des fonctions spéciales ayant le même nom, mais se distinguant par leur signature (nombre et type des arguments). Perl détermine quel exemplaire de la fonction appeler en fonction de la signature (processus analogue à la résolution des méthodes en programmation orientée objet).

multi salue ($nom)         {say "Bonjour $nom"}
multi salue ($nom, $titre) {say "Bonjour $titre $nom"}
salue("George Lucas");    # -> Bonjour George Lucas
salue "Yoda", "Maître";   # -> Bonjour Maître Yoda

Ici, c'est le nombre d'arguments de la fonction qui permet à Perl 6 de déterminer quelle version de salue appeler. La distinction pourrait aussi se faire sur le type (voire le « sous-type »).

Beaucoup des opérateurs et des fonctions ou méthodes internes de Perl 6 sont définis comme des fonctions multiples. Cela signifie qu'en utilisant une signature n'existant pas en interne, il est possible de redéfinir ou surcharger ces fonctions ou opérateurs.

Toutes nos fonctions jusqu'ici se contentaient d'afficher quelque chose à l'écran. Très souvent, il est souhaitable qu'une fonction se contente de prendre des paramètres en entrée et de renvoyer des valeurs de retour, sans avoir d'effet de bord. Cela facilite la conception et la mise au point de programmes.

Voici la définition et l'utilisation d'une fonction renvoyant une valeur utile :

> sub carré ($x) { return $x * $x }
sub carré ($x) { #`(Sub|183561872) ... }
> say carré 3
9

Le mot-clef return indique explicitement que la fonction doit se terminer et renvoyer la valeur donnée. Et l'appel carré 3 renvoie à say la valeur 9. En fait, ce mot-clef n'était pas indispensable ici, car une fonction renvoie implicitement la dernière expression évaluée, si bien que la fonction aurait aussi bien pu s'écrire :

sub carré ($x) { $x ** 2 }

Cela suffit pour des fonctions simples n'ayant qu'un seul point de sortie, mais l'utilisation de return permet de définir finement le comportement d'une fonction et les valeurs de retour selon les conditions rencontrées.