Perl 6 Einführung

Perl 6 ist eine universelle stufenweise typisierte Hochsprache. Perl 6 ist multi-paradigmatisch. Es unterstützt prozedurales, objektorientiertes und funktionales Programmieren.

Um Rakudo-Star zu installieren, führe diese Kommandos in einem Terminalfenster aus:

Mehr Informationen stehen unter: https://rakudo.org/star/source

Folgen Sie der Anleitung für Linux
ODER
Mit homebrew installieren: brew install rakudo-star

Perl 6 Code kann mit dem REPL (Read-Eval-Print Loop) ausgeführt werden. Dazu in ein Terminalfenster perl6 eingeben, Enter] drücken. Darauf hin erscheint ein > Prompt. Nun kann eine Zeile Perl 6 Code eingegeben und wieder [Enter] gedrückt werden. Der REPL gibt das Ergebnis der Zeile aus. Nun kann eine weitere Zeile Code eingegeben und wieder [Enter] gedrückt werden. Um REPL zu verlassen, kann exit eingegeben und [Enter] gedrückt werden.

Alternativ den Code in eine Datei schreiben, abspeichern und ausführen.
Es wird empfohlen, Perl 6-Dateien mit der Dateierweiterung .pl6 zu versehen.
Im Terminal kann nun perl6 filename.pl6 eingegeben und [Enter] gedrückt werden, um den Code auszuführen. Anders als in REPL werden nun nicht automatisch die Ergebnisse jeder Zeile ausgegeben. Um Ausgaben auf dem Terminal zu zeigen, müßte der Code nun zum Beispiel eine Anweisung wie etwa say enthalten.

REPL wird meistens dafür verwendet, eine bestimmte Codestelle auszuprobieren, etwa eine einzelne Zeile.
Programme mit mehr als einer Zeile sollten besser in eine eigene Datei geschrieben werden, aus der sie dann ausgeführt werden.

Einzelne Zeilen können auch nicht-interaktiv auf der Kommandozeilte getestet werden, indem perl6 -e 'Code steht hier' eingegeben und [Enter] gedrückt wird.

Da die meisten Perl-6-Programme in Dateien geschrieben werden, sollte ein guter Text-Editor verwendet werden, der Perl-6-Syntax erkennt.

Selbst verwende und empfehle ich Atom: ein moderner Text-Editorder das Perl 6 Syntaxhighlighting gleich mitbringt. Perl6-fe ist ein alternativer Perl 6 Syntax-Highlighter für Atom, der aus dem Originalpaket stammt und dann vielfach erweitert und korrigiert wurde.

Andere aus der Community verwenden auch Vim, Emacs oder Padre.

Neuere Vim-Versionen haben das Syntax-Highlighting schon inklusive. Emacs und Padre benötigen die Installation von zusätzlichen Packeten.

Wir fangen mit dem hello world Ritual an.

kann auch so geschrieben werden:

Perl 6 unterstützt die sogenannte freie Form/free form: Meistens kann beliebig viel whitespace verwendet werden.

Ein Ausdruch (Statement) ist typischerweise eine logische Code-Zeile, die mit einem Semikolon abgeschlossen wird: say "Hallo" if True;

Eine Expression ist eine Sonderform des Statements, die einen Wert zurückgibt: 1+2 will return 3

Expressions bestehen aus Terms und Operatoren.

Terms sind:

Operatoren werden in Typen klassifiziert:

Ein Skalar enthält einen Wert oder eine Referenz.

Allerlei spezielle Operationen können an einem Skalar ausgeführt werden, abhängig von dem Wert, den er enthält.

Ein Array ist eine variable Liste, die mehrere Werte enthalten kann.

Viele Operationen sind an Array möglich, wie man in der Tabelle unten erkennen kann:

.elems gibt die Anzahl der Elemente in einem Array zurück.
.push() fügt ein Element an das Array an.
Ein Element kann über seine Position im Array abgerufen werden: @tiere[0].
.pop entfernt das letzte Element aus dem Array.
.splice(a,b) entfernt b Elemente ab Position a.

Einige der Methoden, die auf Hashs angewendet werden können sind:

.push: (key => 'Value') fügt ein weiteres Schlüssel-Wert-Paar (key/value pair) hinzu.
.kv gibt eine Liste mit allen Schlüsseln und Werten aus.
.keys gibt eine Liste mit allen Schlüsseln aus.
.values gibt eine Liste mit allen Werten aus.
Einzelne Werte im Hash können wir über den Schlüssel wie folgt adressieren %hash<key>

In den bisherigen Beispielen haben wir nicht erwähnt, welche Typen die Variablen beinhalten sollten.

Im obigen Beispiel zu sehen war der Typ des Wertes der Variable $var zuerst (Str) und dann (Int).

Dieser Programmierstil wird dynamisches Typisieren (dynamic typing) genannt. Dynamisch in dem Sinne, dass Variablen beliebige Typen enthalten können.

Nun probieren wir ein weiteres Beispiel:
Wichtig ist das Int vor dem Namen der Variable.

Das schlägt fehl und gibt diese Fehlermeldung aus: Type check failed in assignment to $var; expected Int but got Str

Was ist passiert? Zuvor wurde bestimmt, dass die Variable vom Typ (Int) sein sollte. Als versucht wurde, einen Wert vom Typ (Str) zuzuweisen ging schlug der Vorgang fehl.

Dieser Programmierstil wird statisches Typisieren (static typing) genannt. Statisch da alle Variablentypen definiert sind bevor ihnen Werte zugewiesen werden, und die Typen sich nicht ändern können.

Perl 6 ist eine stufenweise typisierte Sprache gradually typed; es erlaubt sowohl statisches als auch dynamisches Typisieren.

Nun folgt eine Liste der am häufigsten verwendeten Typen.
Wahrscheinlich werden Sie die ersten beiden nie verwenden, aber zur Information sind sie mit aufgeführt.

Introspektion ist der Vorgang der Informationsabfrage über die Eigenschaften eines Objekts, wie zum Beispiel sein Typ.
In einem vorherigen Beispiel haben wie .WHAT verwendet umd den Typ des Wertes einer Variable abzufragen.

Der Typ einer Variable mit einem zugewiesenen Wert korreliert mit ihrem Wert.
Der Typ einer stark deklarierten leeren Variable ist vom Typ mit dem sie deklariert wurde.
Der Typ einer leeren Variable, die nichtstark deklariert wurde ist (Any)
Um den Wert einer Variable zu löschen, weist man ihr Nil zu.

Bevore eine Variable zum erstenmal verwendet wird, muss sie deklariert werden.

Mehrere Deklaratoren werden in Perl 6 verwendet, in den Beispielen wurde dafür bisher my verwendet.

Der Deklarator my verleiht der Variable lexikalischen Gültigkeitsbereich. Das heißt, die Variable ist nur innerhalb des Blocks verwendbar, in dem sie deklariert wurde.

Ein Block in Perl 6 wird durch { } begrenzt. Wenn noch kein Block da ist, ist der Gültigkeitsbereich der Variable das ganze Perl Skript.

Da eine lexikalische Variable nur in dem Block verfügbar ist, in dem sie definiert wurde, kann die selbe Variable in einem weitern Block erneut definiert werden.

Die bisherigen Beispiele haben gezeigt, wie Variablen Werte zugewiesen werden.
Zuweisung geschieht mit dem = Operator.

Wir können den Wert, der einer Variablen zugewiesen wurde ändern:

Andererseits können wie einen Wert, der an eine Variable gebunden wurde nicht ändern.
Bindung geschieht mit dem := Operator.

Variablenbindungen funktionieren in beide Richtungen, wie man hier erkennen kann.
$a := $b und $b := $a bewirken das Gleiche.

Der Code wird nur ausgeführt, wenn die Bedingung zutrifft.

In Perl 6 können Code und Bedingung auch in umgekehrter Reihenfolge geschrieben werden.
Auch wenn der Code zuerst geschrieben wird, wird immer noch die Bedingung zuerst ausgewertet.

Falls die Bedingung nicht erfüllt wird, können alternative Blöcke ausgeführt werden, und zwar mit:

Die negierte Form einer if-Bedingung kann als unless geschrieben werden.

Dieser Code:

kann auch so geschrieben werden:

Negation in Perl 6 wird entweder mit ! oder mit not erreicht.

unless (condition) wird anstelle von if not (condition) verwendet.

unless kann keine else-Bedingung haben.

with wird wie die if-Bedingung verwendet, testet aber zusätzlich, ob die Variable definiert ist.

Wird der Code ohne Variablenzuweisung ausgeführt, sollte nichts passieren.

without ist die negierte Version von with. Das läßt sich ähnlich unless verstehen.

Wird die erste with Bedingung nicht erfüllt, kann ein weiterer Block mit orwith ausgeführt werden,
with und orwith können mit if und elsif verglichen werden.

Die for Schleife iteriert über mehrere Werte.

Hier haben wir die Interationsvariable $array-wert erzeugt, um die Operation *100 auf jedem Array-Wert durchzuführen.

given ist das Perl 6 eigene Switch Statement.

Nach einem erfolgten Treffer, wird das Matching beendet.

Alternativ kann Perl 6 mit mit proceed angewiesen werden, auch nach einem erfolgten Treffer weiterzumachen.

loop ist eine Alternative zur for Schleife.

Genaugenommen ist loop die Sorte for Schleife, wie sie gerne in der Familie der C-ähnlichen Sprachen verwendet wird.

Perl 6 gehört wohl auch in die Familie der C-ähnlichen Sprachen.

Zwei Subroutinen können verwendet werden, um Shell Kommandos auszuführen:

echo und ls sind gewöhnliche Shell Kommandos.
echo gibt Text auf das Terminal aus (ähnlich say und print in Perl 6)
ls gibt eine Liste aller Dateien und Verzeichnisse im aktuellen Verzeichnis aus

Perl 6 kann den Inhalt eines Verzeichnisses auch ohne Shell Kommandos (etwa ls) lesen.

Noch dazu lassen sich auch Verzeichnisse neu anlegen und auch wieder entfernen.

mkdir erstellt ein neues Verzeichnis.
rmdir löscht ein bestehendes Verzeichnis, sofern es leer ist. Gibt eine Fehlermeldung aus, wenn es nicht leer ist.

Es kann auch geprüft werden, ob ein Pfad existiert, und ob es sich dabei um eine Datei oder ein Verzeichnis handelt:

In dem Verzeichnis, in dem Sie das gleich folgende Skript ausführen, erstellen Sie ein leeres Verzeichnis namens Verzeichnis123 und daneben eine leeree pl6 Datei namens Skript123.pl6

IO.e prüft ob die Datei/das Verzeichnis existiert.
IO.f prüft ob der Pfad eine Datei ist.
IO.d prüft ob der Pfad ein Verzeichnis ist.

Unterprogramm (auch Subroutinen, Routinen, Prozeduren oder Funktionen) sind eine Möglichkeit, ein Unterprogramm zu verpacken.

Die Definition einer Subroutine fämgt mit dem Stichwort sub an. Nachdem sie definiert wurde, kann sie mit ihrem Namen aufgerufen werden.
Hier ein Beispiel:

Dies war ein Beispiel für eine Subroutine, die keine Eingabe benötigt.

Viele Subroutinen brauchen Eingaben um zu funktionieren. Diese Eingaben erfolgen durch Argumente (auch Parameter genannt). Anzahl und Typen der Argumente, die eine Subroutine akzeptiert, nennen sich ihre Signatur.

Die folgende Subroutine akzeptiert ein Argument vom Typ String.

Es lassen sich auch mehrere Subroutinen mit dem gleichen Namen aber verschiedenen Signaturen erstellen. Wird die Subroutine aufgerufen, entscheidet die Laufzeitumgebung, welche der Subroutinen die geeignete ist anhand der Zahl und des Typs der mitgelieferten Argumente. This type of subroutines is defined the same way as normal subs with the exception of swapping the sub keyword with multi.

Wenn eine Subroutine definiert ist, ein Argument anzunehmen, und sie ohne eines aufgerufen wird, scheitert sie.

Alternativ bietet Perl 6 Möglichkeiten Subroutinen auszustatten mit:

Optionale Argumente werden mit einem ? nach dem Argumentnamen versehen.

Wenn der Anwender kein Argument angibt, kann ein voreingestelltes Argument verwendet werden.
Dazu übergibt man dem Argument in der Subroutinendefinition einen Wert.

Funktionen/Subroutinen sind First-Class-Objekt:

Das Konzept läßt sich besonders gut an der map Funktion beschreiben.
map ist eine Funktion höherer Ordnung, sie akzeptiert eine weitere Funktion als Argument.

Wir definierten eine Subroutine namens quadriert, diese quadriert ihr Argument (rechnet das Argument hoch 2) für jedes numerische Argument, das sie erhält.
Dann haben wir die Funktion höherer Ordnung map verwendet und ihr zwei Argumente übergeben, die Subroutine quadriert und ein Array mit Zahlen.
Die Ausgabe ist eine Liste aller quadrierten Elemente des Arrays.

Wird eine Subroutine als Argument übergeben, muss ihrem Namen ein & vorangestellt werden.

Alle Code-Objekte sind in Perl 6 Closures. Das bedeutet, sie können lexikalische Variablen eines äußeren Gültigkeitsbereichs (scope) referenzieren.

Eine anonyme Funktion wird auch Lambda genannt.
Eine anonyme Funktion ist nicht an einen Identifikator (identifier) gebunden, sie hat also keinen Namen.

Wir schreiben das map-Beispiel mit einer anonymen Funktion:

Anstelle die Subroutine zu deklarieren und als Argument dem map zu übergeben, haben wir sie direkt darin definiert.
Diese anonyme Subroutine -> $x {$x ** 2} hat keinen Namen und kann nicht aufgerufen werden.

Im Perl 6 Jargon nennen wir diese Schreibweise einen spitzen Block (pointy block).

In Perl 6 können Methoden verkettet werden, man braucht also nicht länger das Resultat einer Metode der nächsten als Argument zu übergeben.

Bei einem Array von werten sollen die eindeutigen Werte zurückgegeben werden, vom Größten zum Kleinsten sortiert.

Das kann man in etwa so lösen:

Zuerst rufen wir die Funktion unique auf @array auf, dann übergeben wir das Ergebnis als Argument an sort und dann übergeben wir dessen Sortierergebnis an reverse.

Das obige Beispiel kann wie folgt mit Methodenverkettung geschrieben werden:

Man erkennt, dass sich verkettete Methoden leichter lesen lassen.

Der Feed Operator, in einigen Funktionalen Programmiersprachten auch Pipe genannt, bietet eine noch bessere Visualisierung für Methodenverkettung.

Hier sieht man den Fluß der Methodenaufrufe von Oben nach Unten.

Der Rückwärts Feed fungiert genau so wie der Vorwärts Feed, wird nur genau anders herum geschrieben.
Der Fluß der Methoden läuft dann von Unten nach Oben.

Der Hyperoperator >>. ruft eine Methode aud allen Elementen einer Liste auf und gibt eine Liste mit allen Ergebnissen zurück.

Mit dem Hyperoperator können bereits in Perl 6 definierte Methoden wie is-prime aufgerufen werden, die beantworten, ob eine Zahl Primzahl ist oder nicht.
Weiter können wir neue Subroutinen definieren und sie mit dem Hyperoperator aufrufen. Dann muss ein & vor den Namen der Methode vorangestellt werden: &ist-gerade

Dies ist eine praktische Möglichkeit, for-Schleifen zum bearbeiten aller Werte zu vermeiden.

Eine Verknüpfung ist die logische Superposition von Werten.

Im Beispiel unten ist 1|2|3 eine Verknüpfung (junction).

Verwendet man Verknüpfungen, erhält man meistens Autothreading; die Operation wird für jedes Element der Verknüpfung ausgeführt und alle Ergebnisse werden zu einer neuen Verknüpfung zusammengefügt und die wird ausgegeben.

Eine gemütliche Lazy Liste ist eine Liste, die gemütlich/lazy ausgewertet wird.
Gemütliche/Lazy Auswertung vertagt die Berechnung eines Ausdrucks bis sie notwendig wird, und verhindert die Wiederholung der Berechnung bei sich wiederholenden Auswertungen in dem es sie in einer Lookup-Tabelle speichert.

Einige Vorteile sind dabei:

Um eine gemütliche Lazy Liste zu erstellen, verwendet man den Infixoperator …​
Eine gemütliche Lazy Liste besteht aus Ursprungselement(en), einem Generator und einem Endpunkt.

Das Ursprungselement ist 1 und der Endpunkt ist 10. Kein Generator wurde definiert, daher ist der Standardgenerator der Nachfolger (+1)
Ander gesagt kann diese gemütliche/Lazy Liste (falls angefragt) diese Elemente zurückgeben: (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Diese Liste kann (falls angefragt) jede ganze Zahl zwischen 1 und unendlich zurückgeben. Oder andersgesagt alle Ganzen Zahlen.

Die Ursprungselemente sind 0 und 2 und der Endpunkt ist 10. Zwar wurde kein Generator definiert, jedoch kann Perl 6 aus den Ursprungselementen den Generator erkennen (+2).
Diese gemütliche Lazy Liste kann, wenn sie abgefragt werden, die folgenden Elemente zurückgeben (0, 2, 4, 6, 8, 10)

In diesem Beispiel wurde der Generator definiert in { }
Diese gemütliche Lazy Liste kann, wenn sie abgefragt werden, die folgenden Elemente zurückgeben (0, 3, 6, 9, 12)

Objektorientiertes Programmieren ist ein weitverbreitetes Paradigma.
Ein Objekt ist ein Set von miteinander verbundenen Variablen und Subroutinen.
Die Variablen nennt man Attribute und die Subroutinen nennt man Methoden.
Attribute definieren den Zustand (state) und Methoden definieren das Verhalten (behavior) eines Objekts.

Eine Klasse beschreibt die Struktur einer Menge von Objekten.

Um diese Beziehung zu verdeutlichen, verwenden wir ein Beispiel:

In Objektorientierter Lingo sagen wir, Objekte sind Instanzen einer Klasse.

Folgendes Beispiel:

Das Stichwort class wird zur Definition einer Klasse verwendet.
Das Stichwort has wird zur Definition der Attribute einer Klasse verwendet.
Die Methode .new() nennt man einen Konstruktor. Er erschafft ein Object als eine Instanz der (ein Beispiel für die) Klasse mit der sie aufgerufen wurde.

Im obigen Skript enthält eine neue Variable $hans eine Referenz auf eine neue Instanz von "Mensch" definiert durch Mensch.new().
Die Argumente, die an die Methode .new() übergeben wurden, werden nun als Attribute des darunterliegenden Obbjekts verwendet.

Einer Klasse kann ein lexikalischer Gültigkeitsbereich mit my gegeben werden:

Datenkapselung ist ein Konzept der Objektorientierung welches ein Set von Daten und Methoden zusoammenfasst.
Die Daten (Attribute) innerhalb eines Objekts sollten privat sein, also nur aus dem Objekt heraus zugänglich.
Um von außerhalb des Objekts an die Attribute darin zu gelangen, werden Methoden verwendet, die man Accessoren nennt.

Die beiden folgenden Skripte haben das selbe Ergebnis.

Die Methode sag_wert ist ein Accessor. Sie läßt uns auf den Wert der Variable zugreifen, ohne dass wir direkten Zugriff darauf benötigen.

Datenkapselung wird in Perl 6 durch Twigillen vereinfacht.
Twigillen sind Sigillen zweiten Ranges. Sie werden zwischen Sigille und Attributnamen gesetzt.
Zwei Twigillen werden in Klassen verwendet:

Voreingestellt sind alle Attribute privat. Dennoch sei es eine gute Gewohnheit immer die ! Twigille zu verwenden.

Also sollten wir die obige Klasse besser so schreiben:

Wird dem Skript nun dieser Ausdruck hinzugefügt: say $hans.alter;
Das bewirkt diesen Fehler: Method 'alter' not found for invocant of class 'Mensch'
Grund ist, dass $!alter privat ist und nur innerhalb des Objekts verwendet werden darf. Es von Aussen zu probieren bewirkt einen Fehler.

Bei Ersetzen von has $!alter mit has $.alter ist zu sehen, dass say $hans.alter; nun eine Ausgabe bewirkt.

In Perl 6 erben alle Klassen den standardmäßigen .new() Konstruktor.
Dieser kann verwendet werden, Objekte zu erstellen, indem er mit Argumenten ausgestattet wird.
Er kann aber ausschließtlich mit benannten Argumenten verwendet werden.
Im obigen Beispiel ist zu erkennen, dass alle .new() mitgegebenen Argumente benannt waren:

Aber was, wenn nicht jedesmal die Namen aller Attribute mit übergeben werden sollen, wenn ein neues Objekt erstellt werden soll?
Dann muss ein neuer Konstruktor erstellt werden, der Positionsargumente akzeptiert.

Ein Positionsargumente akzeptierender Konstruktor wird, wie oben zu sehen, erstellt.

Klassenattribute sind Attribute, die zur Klasse selbst gehören, nicht jedoch zu ihren Objekten.
Sie können in der Klassendefinition initialisiert werden.
KlassenAttribut werden mit my anstelle von has definiert.
Sie werden mit der Klasse selbst anstelle auf den Objekten aufgerufen.

Bis jetzt verwendeten alle Beispiele Accessoren um an Information aus den Attributen des Objekts zu gelangen.

Wie modifiziert man den Wert eines Attributs?
Dazu müssen wir es als lesen/schreiben bzw. read/write mit den Stichwörtern is rw beschreiben.

Standardmäßig werden alle Attribute als nur lesen bzw. read only deklariert, man kann es aber auch explizit mit is readonly schreiben.

Mehrfachvererbung ist in Perl 6 erlaubt. Eine Klasse kann von vielen anderen Klassen erben.

Die Klasse Kombidiagramm soll zwei Serien enthalten, eine für die tatsächlichen Werte in Balkendiagrammen geplottet, und eine weitere für vorraussichtlichen Werte auf einer Linie geplotted.
Deswegen wurde sie als Kind von Liniendiagramm und Balkendiagramm definiert.
Dabei läßt sich feststellen, dass der Aufruf der Methode plotte im Kombidiagramm nicht das gewünschte Resultat erbracht hat, denn nur eine Serie wurde geplottet.
Warum ist das geschehen?
Kombidiagramm erbt von Liniendiagramm und Balkendiagramm, und beide haben eine Methode namens plotte. Wird diese Methode auf Kombidiagramm aufgerufen, muß Perl 6 diesen Konflikt lösen, indem es eine der beiden geerbten Methoden aufruft.

Um korrekt zu funktionieren muß die Methode plotte die Methode in Kombidiagramm überschrieben werden.

Rollen sind Klassen ähnlich, denn sie sind eine Sammlung von Attribute und Methoden.

Rollen werden mit dem Stichwort role deklariert und Klassen, die die Rolle implementieren können dies mit dem Stichwort does.

Beim Ausführen dieses Skripts läßt sich erkennen: die Ausgabe ist die gleiche wie vorher.

Da sich offensichtlich Rollen genau wie Klassen verhalten, wofür braucht man sie dann?
Um das zu beantworten, ändert man das erste Skript so, dass es Mehrfachvererbung verwendet, eben das Skript indem vergessen wurde, die Methode plotte zu überschreiben.

Werden einundderselben Klasse mehrere Rollen zugewiesen und daraus entsteht ein Konflikt, wird ein Kompilierzeit-Fehler ausgegeben.
Dieser Ansatz ist deutlich sicherer als Mehrfachvererbung, bei der Konflikte keine Fehler sind und erst zur Laufzeit ausgewertet werden.

Kurz: Rollen warnen vor Konflikten.

Introspection ist der Vorgang, etwas über ein Objekt zu erfahren, etwa seine Eigenschaften oder seine Attribute oder seine Methoden.

Introspection wird ermöglicht durch:

Fehlermeldungen sind eine besondere special behavior die zur Ausführungszeit passiert, wenn etwas schief läuft.
Man sagt, Fehlermeldungen werden geworfen (Exceptions are thrown).

Zuerst ein problemlos laufendes Skript:

Nun folgendes Skript, dass eine Fehlermeldung ausgibt/eine Exception wirft:

Immer, wenn ein Fehler passiert (in diesem Fall einem String eine Zahl zuweisen), wird das Programm beendet und weiterer Code wird nicht evaluiert, selbst wenn sie fehlerfrei sind.

Umgang mit Fehlermeldungen (Exception handling) ist der Vorgang, einen Fehler, der geworfen wurde abzufangen (catch), damit das Programm weiterlaufen kann.

Umgang mit Fehlermeldungen mit dem Try-Catch Block.

Der CATCH Block kann genau wie ein given Block definiert werden. Das bedeutet, wir können viele Arten von Fehlern abfangen und verschieden behandeln.

Im Gegensatz zum abfangen von Fehlermeldungen erlaubt Perl 6 auch das explizite Werfen von Fehlermeldungen.
Zweierlei Arten von Fehlermeldungen können geworfen werden:

Ad-hoc Fehlermeldungen werden durch die Funktion die geworfen, der die Nachricht der Fehlermeldung folgt.

Typisierte Fehlermeldungen sind Objekte, daher die Verwendung des .new() Konstruktors im obigen Beispiel.
Alle typisierten Fehlermeldungen stammen von der Klasse X ab, hier ein paar Beispiele:
X::AdHoc ist der einfachste Typ Fehlermeldung
X::IO gehört zu IO Fehlern
X::OS gehört zu OS Fehlern
X::Str::Numeric gehört dazu, dass versucht wurde, aus einem String eine Zahl zu machen

Ein A Regulärer Ausdruck kann wie folgt definiert werden:

Leerzeichen sind dabei normalerweise irrelevant, wenn es nicht anders spezifiziert wird, m/Erle/ und m/ Erle / sind gleich.

Alphanumerische Zeichen und der Unterstrich _ werden so geschrieben, wie sie sind.
Alle sonstigen Zeichen müssen mit einem Rückwärtsschrägstrich (backslash) escaped werden oder von Anführungszeichen umgeben werden.

Zeichen können in Kategorien eingeordnet werden, und wir können gegen diese matchen.
Wir können auch nach dem Inversen der Kategorie matchen (alles ausser diesem):

Matching gegen Kategorien von Zeichen, wie soeben gesehen, erscheint sehr praktisch.
Ein noch systematischerer Ansatz ist es, Unicode Eigenschaften zu verwenden.
Unicode Eigenschaften werdein in <: > eingepackt.

Platzhalter können auch in einer Regex verwendet werden.

Der Punkt . matcht ein einzelnes Zeichen.

Quantifier folgen einem Zeichen und beziffern, wie oft es erwartet wird.

Das Fragezeichen ? bedeutet genau keinmal oder genau einmal.

Das Sternchen * bedeutet genau keinmal oder beliebig oft.

Das Pluszeichen + bedeutet mindestens einmal.

Sobald ein Treffer einer Zeichenfolge gegen eine Regex erfolgreich ist, wird das Übereinstimmungsergebnis in der besonderen Variable $/ abgelegt.

$/ liefert ein Match Objekt (die mit der Regex übereinstimmende Zeichenfolge) zurück.
Follgende Methoden können auf dem Match Objekt aufgerufen werden:
.prematch gibt die Zeichenfolge vor der Übereinstimmung aus.
.postmatch gibt die Zeichenfolge nach der Übereinstimmung aus.
.from gibt die Startposition der Übereinstimmung aus.
.to gibt die Endposition der Übereinstimmung aus.

Ist eine Mailadresse möglicherweise gültig oder sicherlich nicht?
Nur für dieses Beispiel nehmen wir einmal (fälschlich) an, das gültige Mailadresse so aussehen sollen:
Vorname [Punkt] Nachname [@] firma [Punkt] (com/org/net)

Hans.Meier@example.org ist eine gültige Mailadresse

<:L> matcht einen einzigen Buchstaben
<:L>` matcht einen einzigen Buchstaben oder mehrere + `\.` matcht einen einzigen [Punkt] + `\@` matcht ein einziges [@] + `<:L:N> matcht einen Buchstaben und eine Zahl
<:L+:N>+ matcht einen oder mehrere (Buchstaben und Zahlen)

Die Regex kann wie folgt auseinandergenommen werden:

A benannte Regex wird mit dieser Syntax definiert: my regex regex-name { regex definition }
A benannte Regex wird mit dieser Syntax aufgerufen: <regex-name>

MD5 ist eine kryptographische Hashfunktion die einen 128-Bit Hashwert erzeugt.
MD5 hat eine Vielzahl von Anwendemöglichkeiten, nicht zuletzt dabei, einwegenkryptete Passwörter in einer Datenbank vorzuhalten. Registriert sich ein neuer User, wird sein Passwort nicht im Klartext gespeichert, sondern gehasht. Damit wird sichergestellt, dass auch wenn die Datenbank in falsche Hände geraten sollte, ein Angreifer nicht die Passwörter selbst erhalten wird.

Lets say you need a script that generates the MD5 hash of a password in preparation for storing it in the DB.

Zum Glück gibt es schon ein Perl 6 Modul, das den MD5 Algorithmus implementiert. Zeit es zu installieren:
zef install Digest::MD5

Dann das folgende Skript ausführen:

Um die md5_hex()-Funktion ausführen zu können, die die Hashs erstellt, muß das dafür notwendige Modul geladen werden.
Das Stichwort use lädt das Modul, damit es im Skript verfügbar ist.

Die obigen 3 Zeilen zeigen verschiedene Wege, Zeichen anzuzeigen:

Der Buchstabe á kann so geschrieben werden:

NFC gibt den eindeutigen Codepoint.
NFD teilt das Zeichen in die Codepoints seiner Teile auf und gibt diese aus.
uniname gibt den Namen des Codepoints aus.

Meistens laufen die Aufgaben innerhalb eines Programms nacheinander ab.
Das ist gut so, solange es nicht zu lange dauert.

Perl 6 hat Möglichkeiten, mehrere Dinge gleichzeitig zu erledigen.
Parallelität hat zweierlei Bedeutungen:

Letzteres zuerst.