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

• TMTOWTDI (prononcé Tim Toady): There is more than one way to do it: c’est-à-dire « Il y a plus d’une façon de le faire »

• Easy things should stay easy, hard things should get easier, and impossible things should get hard: « Les choses faciles doivent rester faciles, les choses difficiles devraient devenir plus faciles, et les choses impossibles devraient devenir difficiles »

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

• Raku est une spécification de langage avec une suite de tests. Les implémentations qui passent la suite de tests sont considérées comme du Raku.

• Rakudo est un compilateur pour Raku.

• Rakudobrew est un gestionnaire d’installation pour Rakudo.

• Zef est un installeur de modules pour Raku.

• Rakudo Star est un paquet qui comprend : Rakudo, Zef, une collection de modules, et de la documentation.

Quatre solutions possibles :

• Suivez les mêmes étapes que celles indiquées pour l’installation sur Linux

• Installer avec homebrew: brew install rakudo-star

• Installez avec MacPorts: sudo port install rakudo

• Téléchargez l’installateur (fichier avec l’extension .dmg) depuis https://rakudo.org/latest/star/macos

1. Pour les architectures 64-bit : Téléchargez le dernier installeur (extension .msi) ici https://rakudo.org/latest/star/win

2. Après l’installation, assurez vous que C:\rakudo\bin soit dans votre PATH.

1. Obtenez l’image officielle docker pull rakudo-star

2. Ensuite exécutez docker run -it rakudo-star

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

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

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

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

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

Un IDE spécifique à Raku dévellopé par Edument est disponible ici sous le nom de Comma)

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

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

Nous allons commencer avec le rituel hello world.

qui peut aussi s’écrire:

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

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

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

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

Les termes sont des:

• variables: une valeur qui peut être manipulée ou changée.

• valeurs littérales: une valeur constante comme un nombre ou une chaîne.

Les opérateurs sont classés en types:

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

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

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

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

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

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

.push: (clef => 'valeur') ajoute une nouvelle paire clef/valeur.
.kv renvoie la liste contenant toutes les clefs et valeurs.
.keys renvoie une liste des clefs.
.values renvoie une liste des valeurs.
On peut accéder à la valeur particulière d’un hachage en spécifiant sa clef, comme suit: %hachage<clef>

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

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

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

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

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

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

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

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

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

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

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

Avant d’utiliser une variable pour la première fois, elle doit être déclarée.

Plusieurs déclarateurs peuvent être utilisés dans Raku, my est ce que nous avons utilisé jusqu’ici.

Le déclarateur my donne à la variable une portée lexicale. En d’autres termes, la variable ne sera accessible que dans le bloc où elle a été déclarée.

Un bloc en Raku est délimité par { }. Si aucun bloc n’est trouvé, la variable sera disponible dans l’ensemble du script (on dit alors parfois qu’elle est globale au script).

Comme une variable est uniquement accessible dans le bloc où elle est définie, le même nom de variable peut être redéfini dans un autre bloc.

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

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

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

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

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

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

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

• else

• elsif

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

Le code suivant:

peut aussi être écrit ainsi:

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

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

unless ne peux pas avoir une clause else.

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

Si vous exécutez le code sans attribuer une valeur à la variable, rien ne devrait arriver.

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

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

La boucle for itère sur plusieurs valeurs.

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

given est l’équivalent Raku de l’instruction switch dans d’autres langages.

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

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

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

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

Raku appartient à la famille C.

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

• run exécute une commande externe sans impliquer le shell

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

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

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

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

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

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

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

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

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

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

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

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

La routine ci-dessous accepte une chaîne pour argument:

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

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

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

• Arguments optionnels

• Arguments par défaut

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

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

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

• elles peuvent être passées comme un argument

• elles peuvent être renvoyées par une fonction

• on peut les affecter à une variable

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

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

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

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

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

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

En dialecte Raku nous l’appelons un bloc pointu (pointy block).

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

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

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

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

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

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

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

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

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

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

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

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

Une jonction est une superposition logique des valeurs.

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

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

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

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

• Un gain de performance évitant les calculs inutiles

• La possibilité de construire des structures de données potentiellement infinies

• La possibilité de définir une structure de contrôle

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

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

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

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

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

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

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

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

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

Voyez le script ci-dessous:

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

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

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

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

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

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

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

• ! est utilisé pour déclarer explicitement qu’un attribut est privé.

• . est utilisé pour générer automatiquement un accesseur pour un attribut.

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

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

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

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

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

• nom => 'François'

• age => 23

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

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

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

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

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

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

L’héritage multiple est disponible en Raku. Une classe peut hériter de plusieurs autres classes.

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

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

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

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

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

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

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

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

Les rôles vous avertirons en cas de conflit.

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

L’introspection est facilitée par:

• .WHAT renvoie la classe depuis laquelle l’objet a été créé.

• .^attributes renvoie une liste qui contient tous les attributs de l’objet.

• .^methods renvoie toutes les méthodes implémentables de l’objet.

• .^parents renvoie toutes les classes parentes de la classe à laquelle appartient l’objet.

• ~~ est appelé l’opérateur de correspondance intelligente (smart-match). Il renvoie Vrai si l’objet correspond à sa classe de création ou à une de celles dont elle a hérité.

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

Le script ci-dessous, qui s’exécute correctement:

Maintenant, voici un script analogue qui lance une exception:

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

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

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

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

A l’inverse de capturer les exceptions, Raku vous permet aussi d’en lancer.
On peut lancer deux types d’exceptions:

• les exceptions ad-hoc

• les exceptions typées

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

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

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

• /soleil/

• m/soleil/

• rx/soleil/

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

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

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

La section précédente montre l’utilité d’utiliser des catégories de caractères.
Ceci dit, une approche plus systématique pourrait être d’utiliser les propriétés Unicode.
Les propriétés Unicode sont notées à l’intérieur de <: >

Les métacaractères (wildcards) peuvent également être utilisés dans les regex.

Le point . signifie n’importe quel caractère unique.

Les quantificateurs viennent après un caractère et sont utilisés pour déterminer le nombre de fois qu’il doit apparaître.

Le point d’interrogation ? signifie zéro ou une fois.

L’astérisque * signifie zéro ou plusieurs fois.

Le + signifie au moins une fois.

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

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

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

[email protected] est une adresse mail valide

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

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

• nom <:L>+

• [point] \.

• prénom <:L>+

• [arobase] \@

• nom de la société <:L+:N>+

• [point] \.

• com/org/net <:L>+

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

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

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

Heureusement, Raku possède un module qui implémente l’algorithme de hachage MD5. Installons-le:
zef install Digest::MD5

Maintenant, lançons le script suivant:

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

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

1. Ecriture directe (graphème)

2. Utilisation de \x suivit du point de code

3. Utilisation de \c et du nom du point de code

La lettre á peut être écrite:

• en utilisant son point de code unique \x00e1

• ou comme la combinaison des points de code de: a et de l’accent aigu \x0061\x0301

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

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

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

• Parallélisme des taches: Deux (ou plus) expressions indépendantes lancées en parallèle.

• Parallélisme des données: Un expression unique itérée sur une liste d’éléments en parallèle.

Commençons par ce dernier.

Considérez le code C ci-dessous qui définit la fonction hellofromc. Cette fonction affiche sur le terminal Bonjour depuis C. Elle de prend pas d’argument et ne retourne aucune valeur.

Suivant votre système d’exploitation, lancez les commandes suivantes pour compiler ce code C dans une librairie.

Dans le même dossier où vous avez compilé votre librairie C, créez un nouveau fichier Raku qui contient le code suivant, et lancez-le.

D’abord nous avons déclaré l’utilisation du module NativeCall.
Puis nous avons créé une constante LIBPATH qui contient le chemin vers la librairie C.
Notez que $*CWD renvoie le dossier actuel de travail.
Puis nous avons créé une nouvelle routine Raku nomée hellofromc() qui va agir comme envellope pour la fonction C du même nom qui se trouve dans LIBPATH.
Cela est possible en utilisant le trait is native.
Puis nous appelons notre routine Raku.

Ce qui revient simplement à déclarer une routine avec un trait is native puis le nom de la librairie C.

Dans la partie ci-dessus nous avons vu comment appler une simple fonction C en l’encepsulant dans une routine Raku qui a le même nom par l’utilisation du trait is native.

Dans certains cas, nous pourions avoir besoin de changer le nom de la routine Raku.
Pour ce-faire, nous utilisons le trait is symbol.

Modifions notre scrit Raku et renommons la routine hellofromc en hello.