Raku Inleiding

Raku is een hogere programmeertaal voor algemeen gebruik met graduele typering. In Raku kan met diverse paradigma’s geprogrammeerd worden. Ondersteund worden onder andere procedureel, object-georiënteerd en functioneel programmeren.

Voer de volgende commando’s uit in een Terminal venster om Rakudo Star te installeren:

Zie https://rakudo.org/star/source voor meer opties.

MacOS kent vier mogelijkheden:

Je kunt eenvoudig Raku code uitvoeren in de REPL (Read-Eval-Print-Loop, oftewel een lees, evalueer, print, lus). Open daarvoor een terminalvenster, type perl6 en druk op [Enter]. Er verschijnt dan een > prompt. Vervolgens kun je een regel code intypen en weer op [Enter] drukken. De REPL zal dan de uiteindelijke waarde van die code laten zien op het scherm. Je kunt dan weer een regel code intypen, of exit intypen en op [Enter] drukken om de REPL te verlaten.

Je kunt je code natuurlijk ook opslaan in een bestand, dat je daarna gaat uitvoeren. We raden aan om een Raku script de extensie .raku te geven, zodat het later te herkennen is als Raku bestand. Voer het bestand uit door perl6 bestandsnaam.raku in het terminal venster in te typen en op [Enter] te drukken. Anders dan bij de REPL zal die niet automatisch het resultaat van elke regel laten zien: daarvoor moet je een opdracht als say in je programma plaatsen om iets te tonen.

De REPL wordt meestal gebruikt om een specifiek stukje code uit te proberen, meestal niet meer dan één enkele regel. Voor programma’s die uit meer dan één regel bestaan, wordt het aangeraden om die regels in een bestand op te slaan en dan dat bestand uit te voeren.

Je kunt ook een regel code non-interactief uitproberen op de commando-regel in een terminal venster, door perl6 -e 'jouw regel code' in te typen en dan op [Enter] te drukken.

Aangezien je het grootste deel van je tijd Raku programma’s in bestanden aan het opslaan bent, is het handig om een goede editor te hebben die Raku syntax herkent.

Ik gebruik Atom en raadt het gebruik daarvan ook aan. Het is een moderne tekst-editor die standaard uitgeleverd wordt met Raku syntax-markeerder. Perl6-fe is een alternatieve Raku syntax-markeerder voor Atom, afgeleid van het origineel, maar met vele bug-fixes en toevoegingen.

Andere mensen in de gemeenschap gebruiken ook Vim, Emacs of Padre.

Recente versies van Vim worden standaard uitgeleverd met een syntax-markeerder. Emacs en Padre hebben de installatie van extra bibliotheken nodig.

Laten we beginnen met het hello world ritueel.

hetgeen ook geschreven kan worden als:

Raku kent weinig beperkingen: over het algemeen kun je zoveel spaties (witruimte) gebruiken als je zelf wilt. In een aantal gevallen is de witruimte wel van belang.

Opdrachten bestaan over het algemeen uit een regel code die beëindigd wordt door een punt-komma: say "Hallo" if True;

Expressies zijn een speciaal soort opdracht die resulteren in een waarde: 1+2 geeft 3 terug

Expressies bestaan uit Termen en Operatoren.

Termen zijn:

Operatoren worden onderverdeeld in deze typen:

Onderstaande tabel toont de meest voorkomende operatoren.

Door een R te plaatsen direct voor een operator, zorg je ervoor dat de termen omgewisseld worden.

Herleidingsoperatoren werken op lijsten. Je maakt een herleidingsoperator door vierkante haken om de operator te plaatsen []

Een scalar kan één waarde bevatten.

Afhankelijk van het type waarde dat een scalar bevat, kun je daar bepaalde operaties op uitvoeren.

Arrays bestaan uit een lijst van scalar variabelen.

Vele operaties kunnen op arrays uitgevoerd worden, zoals getoond in onderstaand voorbeeld:

.elems geeft het aantal elementen in een array.
.push() voegt een element toe aan een array.
We kunnen een specifiek element van een array bekijken door de positie aan te geven @dieren[0].
.pop verwijdert het laatste element van het array.
.splice(a,b) verwijdert b elementen vanaf positie a.

Dit zijn een aantal van de methoden die men op een hash kan uitvoeren:

.push: (naam => 'Waarde') voegt een nieuwe naam/waarde paar toe.
.kv geeft een lijst met alle namen en waarden terug.
.keys geeft een lijst met alle namen terug.
.values geeft een lijst met alle waarden terug.
De waarde behorende bij een gegeven naam kun je opvragen door die naam te specificeren %hash<naam>

In de voorafgaande voorbeelden hebben we niet het type van de waarde aangegeven die in een variabele opgeslagen kan worden.

Zoals je kunt zien in bovenstaand voorbeeld, was het type van de waarde in $var eerst (Str) en daarna (Int).

Deze stijl van programmeren wordt dynamische typering (dynamic typing) genoemd. Dynamisch in de betekenis dat de variable waarden mag bevatten van elk (Any) type.

Probeer nu onderstaand voorbeeld uit te voeren:
Merk op dat we Int voor de naam van de variabele hebben geplaatst.

Dit zal fout gaan en terug komen met het foutbericht: Type check failed in assignment to $var; expected Int but got Str

Wat hier gebeurde is dat we van te voren hadden aangegeven dat de variabele alleen maar (Int) mag accepteren. Toen we probeerden om er een string (Str) aan toe te wijzen, was dat niet mogelijk en ging het fout.

Deze stijl van programmeren wordt "statische typering" (static typing) genoemd. Statisch omdat het type van variabelen wordt gedefinieerd voordat er aan wordt toegewezen, en deze later niet kan worden veranderd.

Raku wordt aangeduid met "graduele typering": het laat namelijk zowel statische als dynamische typering toe.

Je zult hoogstwaarschijnlijk de eerste twee nooit gebruiken, maar we laten ze hier zien om je te laten weten dat ze bestaan.

Met introspectie bedoelen we het process waarmee we informatie over de eigenschappen van een object kunnen bekijken, zoals het type.
In een van de vorige voorbeelden gebruikten we .WHAT om het type van een variabele te achterhalen.

Het type van een variabele waarin een waarde is opgeslagen, is gecorreleerd aan die waarde.
Het type van een lege variabele die gespecificeerd is met een type, is het type waarmee het werd gespecificeerd.
Het type van een lege variabele die niet is gespecificeerd met een type, is (Any)
Om de waarde uit een variabele te verwijderen, kun je de waarde Nil toewijzen.

Voordat men een variabele voor de eerste keer kan gebruiken, moet deze worden gedefinieerd.

Dit kan op diverse manieren in Raku, my is wat we tot nu toe in de bovenstaande voorbeelden hebben gebruikt.

Met my geeft men de variabele een statisch bereik (ook wel lexicaal bereik genoemd). In andere woorden, de variabele zal alleen maar toegankelijk zijn in het gebied (scope) waarin het was gedefinieerd.

Zo’n gebied (scope) wordt in Raku begrensd door { }. Een variabele zal toegankelijk zijn in het gehele Raku script als er geen gebiedsbegrenzing gevonden wordt.

Aangezien zo’n variabele alleen toegankelijk is in het gebied waarin het was gedefinieerd, kan men dezelfde naam voor een variabele gebruiken in een ander gebied.

We hebben in de vorige voorbeelden gezien hoe we waarden aan variabelen kunnen toewijzen.
Toewijzing wordt gedaan met de = operator.

We kunnen de waarde van een variabele veranderen:

Daarentegen kunnen we de waarde van een variabele niet veranderen als deze is verbonden met een waarde.
Verbinding wordt gedaan met de := operator.

Het verbinden van variabelen werkt twee kanten op, zoals je al gezien hebt.
$a := $b en $b := $a hebben hetzelfde effect.

De code in het bereik van de conditionele constructie wordt alleen maar uitgevoerd als de conditie waar (True) is.

In Raku kunnen we de volgorde van de code en de conditie omkeren.
Maar zelfs als de volgorde is omgekeerd, zal de conditie altijd eerst worden uitgevoerd.

We kunnen alternatieve bereiken voor uitvoering aangeven voor het geval dat de conditie niet waar is:

De tegenovergestelde, ontkennende versie van een if command is unless (tenzij).

Deze code:

Kan geschreven worden als:

Ontkenning (negation) wordt in Raku gedaan met ! of not.

unless (conditie) kan worden gebruikt in plaats van if not (conditie).

unless kan geen else bereik hebben.

with gedraagt zich als een if commando, maar kijkt of de variabele een waarde heeft.

Als je deze code uitvoert zonder dat je een waarde aan de variabele hebt toegekend, dan zou je geen uitvoer moeten zien.

without is de ontkennende versie van with. Net als unless van if.

Als de eerste with niet waar is, dan kan men een alternatief bereik aangeven met orwith.
Je kunt with en orwith zien als een soort if en elsif.

Met het for commando kun je over een aantal waarden repeteren.

Merk op dat we een lusvariabele $array-item aanmaken om de operatie *100 op elk element van het array uit te kunnen voeren.

given is het Raku equivalent van het switch commando in andere programmeertalen, maar het is veel krachtiger.

Het testen van condities stops zodra een conditie van een when waar is geweest.

Met proceed kun je in Raku aangeven dat je door wilt gaan met testen van condities nadat een conditie waar was.

loop is een andere manier om een for lus aan te geven.

In feite is loop precies zoals for lussen geschreven worden in de familie C-programmeertalen.

Raku hoort bij de familie C-programmeertalen.

Deze twee subroutines kunnen worden gebruikt om externe commando’s uit te voeren:

echo en ls zijn veel voorkomende commando’s op Linux/OS X:
echo drukt de argumenten af (het equivalent van say in Raku)
ls laat alle bestanden en directories zien in de huidige directory

dir is het equivalent van ls bij Windows.

Raku kan de inhoud van een directory ook direct tonen zonder dat er externe commando’s voor hoeven te worden uitgevoerd, net zoals in een van de vorige voorbeelden.

Tevens kun je ook nieuwe directories aanmaken en verwijderen.

mkdir maakt een nieuwe directory aan.
rmdir verwijdert een lege directory. Geeft een foutmelding terug indien niet leeg.

Je kunt ook kijken of een specifieke naam bestaat, en of het een bestand of een directory is:

Maak in de directory waar je dit script gaat uitvoeren een lege directory dir123 en een leeg bestand genaamd script123.raku

IO.e geeft terug of de naam bestaat.
IO.f geeft terug of het een bestand is.
IO.d geeft terug of het een directory is.

Subroutines (ook wel subs of functies) zijn een manier om een stuk functionaliteit in een pakketje te stoppen.

De definitie van een subroutine begint met het sleutelwoord sub. Na de definitie kun je het aanroepen met de naam die je het gegeven hebt.
Bekijk onderstaand voorbeeld:

Het vorige voorbeeld laat een subroutine zien die geen invoer nodig heeft.

Veel subroutines hebben een vorm van invoer nodig om hun werk te kunnen doen. Die invoer wordt gegeven door argumenten. Een subroutine mag 0 of meer parameters definiëren. Het aantal en het type van de parameters die door een subroutine worden gedefinieerd, noemen we de signatuur.

Onderstaande subroutine accepteert een string argument.

Het is mogelijk om meer dan één subroutine met dezelfde naam, maar met een verschillende signatuur, te definiëren.

Op het moment dat de subroutine wordt aangeroepen, zal de uitvoerder besluiten welke versie van de subroutine werkelijk zal worden aangeroepen, afhankelijk van het aantal en het type van de gegeven argumenten. Dit soort subroutines wordt op dezelfde manier gedefinieerd als normale subroutines, maar in plaats van sub worden ze gedefinieerd met multi.

Als een subroutine is gedefinieerd om een argument te accepteren en we roepen het aan zonder dat benodigde argument, dan zal er een fout optreden.

Als alternatief biedt Raku de mogelijk om subroutines te definiëren met:

Je kunt een optionele parameter aangeven door een ? achter de naam te plaatsen.

Als de gebruiker een bepaald argument niet meegeeft, dan wordt de eventuele default waarde van de parameter gebruikt.
Dit wordt aangegeven door een waarde toe te wijzen aan de parameter in de definitie van de subroutine.

Alle subroutines die we tot nu toe hebben gezien doen iets en laten dan het resultaat op het scherm zien.

Ook al is dit heel normaal, soms willen we dat een subroutine een waarde teruggeeft dat we later in het programma kunnen gebruiken.

Onder normal omstandigheden is de waarde van de laatste regel van een subroutine de waarde die door de subroutine terug wordt gegeven.

Voor de duidelijkheid is het wellicht een goed idee om expliciet aan te geven wat we terug willen geven. Dit kunnen we doen met het return sleutelwoord.

Functies en subroutines zijn ook objecten, net als alle andere:

Een prachtig voorbeeld om dit concept te demonstreren is de map functie.
map is een zogenaamde hogere orde functie, want het accepteert een andere functie als argument.

We hebben een subroutine kwadrateer gedefinieerd die het argument tot de tweede macht verheft.
Vervolgens hebben we map aangeroepen met twee argumenten: een subroutine en een array.
Het resultaat is dat alle elementen van het array zijn gekwadrateerd.

Merk op dat als we een subroutine als argument willen doorgeven, we een & voor de naam moeten zetten.

Een anonieme functie wordt ook wel een lambda genoemd.
Een anonieme functie is niet bekend onder een naam (want die heeft het niet).

Laten we het map voorbeeld herschrijven met een anonieme functie

Merk op dat in plaats van een subroutine te declareren en het door middel van de naam als argument aan map door te geven, we het direct in de aanroep definiëren.
De anonieme subroutine -> $x { $x ** 2 } kan niet als zodanig worden aangeroepen want het heeft geen naam.

In Raku noemen we deze notatie een pointy block.

In Raku kun je methoden aan elkaar koppelen, zodat je niet langer het resultaat van de aanroep van de ene subroutine als een argument aan een andere hoeft te geven.

Laten we het geval bekijken waarbij we een array met waarden kregen. Je wordt gevraagd om alle unieke (maar een keer voorkomende) waarden uit het array te halen en te sorteren van hoog naar laag.

Je zou dit probleem kunnen oplossen door iets te schrijven als:

Eerst roepen we de unique functie aan op @array. Het resultaat daarvan geven we als argument aan sort en dan geven we het resultaat daarvan door aan reverse.

In tegenstelling tot bovenstaand voorbeeld mag je methodes aan elkaar koppelen in Raku.
Bovenstaand voorbeeld kan dus als volgt worden geschreven, waarbij we gebruik maken van het aankoppelen van methoden (method chaining):

Je kunt zien dat het aankoppelen van methoden veel beter leest.

De aanvoer operator, ook wel pipe genoemd in sommige functioneel programmeertalen, geeft een nog beter visualisatie van het aankoppelen van methoden.

Zoals je kunt zien is de volgorde van de aanroepen van de methoden van voor naar achter.

De achterwaardse aanvoer is net als de voorwaardse aanvoer, maar dan andersom.
De volgorde van de aanroepen van de methoden is van achteren naar voren.

De hyper operator >>. roept de methode aan op elke element van een lijst en geeft een lijst terug met het resultaat van die aanroepen.

Met de hyper operator kunnen we methoden aanroepen die standaard al in Raku zijn gedefinieerd, zoals is-prime dat ons vertelt of een getal een priemgetal is of niet.
Daarnaast kun je nieuwe subroutines definiëren en ze aanroepen met de hyper operator. In dat geval moeten we een & voor de naam plaatsen, bijvoorbeeld is-even

Dit is erg practisch want daardoor hoeven we geen for lus te schrijven om over elk element te itereren.

Een junctie is een logische superpositie van waarden.

In onderstaand voorbeeld is 1|2|3 een junctie.

Het gebruik van juncties zorgt meestal voor zogenaamde autothreading; een opdracht wordt voor elk element van de junctie uitgevoerd en de resultaten daarvan worden in een nieuwe junctie opgeslagen en teruggegeven.

Een luie lijst is een lijst die lamlendig wordt geëvalueerd.
Lamlendig evalueren stelt de evaluatie van een expressie uit totdat deze echt nodig is en probeert herhaalde evaluaties te voorkomen door resultaten op te slaan.

De voordelen zijn:

Om een luie lijst te maken gebruiken we de …​ infix operator.
Een luie lijst heeft een of meer startelementen, een generator en een eindpunt.

Het start element is 1 en het eindpunt is 10. Er is geen generator aangegeven, dus de default generator wordt gebruikt (+1).
In andere woorden, deze luie lijst zal de volgende waarden teruggeven (als daarom wordt gevraagd): (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Deze luie lijst kan een getal tussen 1 en oneindig geven, in andere woorden alle natuurlijke getallen.

De startelementen zijn 0 en 2 en het eindpunt is 10. Er is geen generator aangegeven, maar door de aangegeven startelementen kan Raku deduceren dat de generator (+2) is
Deze luie lijst zal de volgende waarden teruggeven (als daarom wordt gevraagd): (0, 2, 4, 6, 8, 10)

In dit voorbeeld specificeren we expliciet een generator tussen { }
Deze luie lijst zal de volgende waarden teruggeven (als daarom wordt gevraagd): (0, 3, 6, 9, 12)

Alle code objecten in Raku zijn zogenaamde closures, hetgeen betekent dat ze kunnen refereren aan lokale variabelen die zichtbaar zijn buiten het directe eigen bereik.

Indien je het bovenstaande programmaatje uitvoert, dan zal het Goede morgen Jan Jansen op het scherm tonen.
Dit is een tamelijk simpel voorbeeld. Het interessante aan dit voorbeeld is dat de begroeting (binnenste) subroutine teruggegeven were door de buitenste subroutine voordat het uitgevoerd werd.

$groeter is nu een closure geworden.

Een closure is een speciaal soort object dat twee zaken combineert:

Die omgeving bestaat uit elke lokale variabele die "zichtbaar" (in-scope) was op het moment dat de closure werd aangemaakt. In dit geval, $groeter is een closure waarin zich zowel de begroeting subroutine bevat als ook de Jan Jansen string die bestond toen de closure werd aangemaakt.

Laten we eens naar een interessanter voorbeeld kijken:

In dit voorbeeld hebben we een subroutine groeter-generator($periode) gemaakt die één enkel argument $periode verwacht, en een nieuwe subroutine teruggeeft. Deze subroutine verwacht één enkel argument $naam waarmee de begroeting wordt geconstrueerd die wordt teruggegeven.

In feite is groeter-generator een subroutine fabriek. In dit voorbeeld gebruiken we deze groeter-generator om twee nieuwe subroutines aan te maken. De ene zegt Goede morgen, en de andere zegt Goede avond.

$smorgens en $savonds zijn allebei closures. Ze delen dezelfde subroutine definitie, maar hebben verschillende omgevingen.
In de omgeving van $smorgens heeft $periode de waarde morgen. In de omgeving van $savonds heeft $periode de waarde avond.

Object Georiënteerd Programmeren is een van de programmeerstijl paradigma’s die tegenwoordig veel wordt gebruikt.
Een object is een verzameling van variabelen en subroutines die bij elkaar gevoegd zijn.
De variabelen noemen we attributen en de subroutines noemen we methoden.
Attributen bepalen de staat van een object, methoden bepalen het gedrag van het object.

Een klasse definieert de structuur van een verzameling objecten.

Bijkijk onderstaand voorbeeld om deze relatie beter te begrijpen:

In het taalgebruik van object georiënteerd programmeren zeggen we dat de objecten instanties zijn van een klasse.

Bekijk het onderstaande script:

Met het class sleutelwoord definieert men een klasse.
Met het has sleutelwoord definieert men een attribuut van een klasse.
De .new() methode wordt een constructeur genoemd. Het maakt een object als een instantie van de klasse waarop het wordt aangeroepen.

In het bovenstaande script, bevat de variabele $jan de nieuwe instantie van "Mens" aangemaakt met Mens.new().
De argumenten op naam die we aan de .new() methode meegeven, worden gebruikt om de attributen van het nieuwe object te initialiseren.

We kunnen een klasse ook een lexicaal gebied geven door middel van my:

Inkapseling is een concept uit het object georiënteerd programmeren waarmee we de bundeling van data en methoden aangeven.
De gegevens (attributen) binnen een object zouden privé moeten zijn. In andere woorden, alleen maar toegankelijk vanaf binnen in het object.
Om toegang te verlenen aan de attributen vanaf buiten het object, gebruiken we methoden die we accessors noemen.

Onderstaande scripts geven hetzelfde resultaat.

De subroutine geef-var kan men als een accessor beschouwen. Het maakt het mogelijk om aan de waarde van de variabele te komen zonder er direct toegang daarvoor nodig te hebben.

Inkapseling wordt in Raku mogelijk gemaakt door middel van zogenaamde twigils.
Twigils zijn secondaire sigils. Ze worden tussen de sigil en de naam van het attribuut geplaatst.
Bij klassen kunnen twee sigils worden gebruikt:

Als men geen twigil meegeeft, is een attribuut privé. Voor de leesbaarheid is het een goede gewoonte om in zo’n geval altijd de ! twigil te gebruiken.

Met wat we zojuist gezien hebben, zouden we bovenstaande klasse moeten herschrijven als:

Voeg het volgende commando to: say $jan.leeftijd
Het zal de volgende fout geven: Method 'leeftijd' not found for invocant of class 'Mens'
De reden hiervoor is dat $!leeftijd privé is en daardoor alleen maar binnen het object gebruikt kan worden. Pogingen om aan het attribuut te komen van buiten het object zal je een foutmelding geven.

Vervang nu has $!leeftijd with has $.leeftijd en bekijk dan het resultaat van say $jan.leeftijd;

Alle klassen hebben beschikking over een .new() constructeur door overerving.
Het kan worden gebruikt om objecten aan te maken door het argumenten te geven.
De default constructeur accepteert alleen argumenten op naam.
Als je bovenstaande voorbeelden bekijkt, dan zul je zien dat alle argumenten die we aan .new() hebben gegeven, op naam zijn:

Wat als ik niet telkens de naam van elk attribuut wil meegeven als ik een nieuw object wil maken?
In dat geval moeten we een andere constructeur maken die argumenten op positie accepteert.

Klasse Attributen zijn attributen die bij de klasse zelf horen en niet bij de objecten van die klasse.
Zij kunnen worden geïnitialiseerd bij de definitie.
Klasse attributen worden gedefinieerd met my in plaats van met has.
Zij worden aangeroepen op de klasse zelf in plaats van op haar objecten.

In alle voorbeelden die we tot nu toe hebben gezien, hebben we accessors alleen maar gebruikt om informatie uit een object te halen.

Maar wat nu als we de waarde van een attribuut willen veranderen?
In dat geval moeten we die attribuut als lees/schrijf markeren met de sleutelwoorden is rw (read/write).

Als je bij de definitie niets aangeeft, wordt een attribuut als alleen lezen gedefinieerd, maar je kunt ook expliciet is readonly aangeven.

Meervoudige overerving is toegestaan in Raku. Een klasse kan van meer dan één andere klasse erven.

De combo-diagram klasse zou in staat moeten zijn om de twee reeksen van waarden, een van "verkocht" in een staafdiagram en een van "voorspeld" in het lijndiagram, te tonen.
Dat is de reden waarom we het hebben gedefinieerd als een kinderklasse van lijndiagram en staafdiagram.
Je hebt waarschijnlijk gemerkt dat het aanroepen van de methode plot op het combo-diagram niet het gewenste resultaat gaf. Slechts één reeks van waarden werd getoond.
Waarom gebeurde dit?
combo-diagram erft van lijndiagram en staafdiagram en beide hebben ze een methode die plot heet. Als we die methode op combo-diagram aanroepen zal Raku dit conflict proberen op te lossen door één van de geërfde methoden aan te roepen.

Om ervoor te zorgen dat dit correct functioneert, hadden we een methode plot in de combo-diagram klasse moeten definiëren.

Rollen zijn net als klassen in de zin van dat zij een verzameling van attributen en methoden zijn.

Rollen kunnen worden gedefinieerd met het sleutelwoord role en klassen die een rol willen "spelen" kunnen dat aangeven met het does sleutelwoord.

Voer het bovenstaande script uit en je zult zien dat de resultaten hetzelfde zijn.

Nu zul je jezelf afvragen: als rollen net als klassen werken, wat is dan hun nut?
Om deze vraag te beantwoorden passen we het eerste script dat we gebruikten om meervodige overerving te laten zien, degene waarin we hadden vergeten om de plot methode te definiëren.

Als een klasse meer dan één rol doet en er daarbij een conflict optreedt, dan zal de compiler een foutmelding geven.
Dit is een veel veiligere aanpak dan meervoudige overerving waarbij conflicten niet als een probleem worden gezien en er bij de uitvoering zo maar iets gedaan wordt.

Rollen waarschuwen je wanneer er een conflict is.

Introspectie is het verkrijgen van informatie over de eigenschappen van een object, zoals het type, haar attributen of haar methoden.

Introspectie is mogelijk door:

Exceptions zijn de uitzonderingsgevallen die optreden bij het uitvoeren van een programma op het moment dat er iets fout gaat.
We zeggen dat exceptions worden geworpen (thrown).

Bekijk onderstaand script dat correct kan worden uitgevoerd:

Bekijk nu onderstaand script dat een exception werpt:

Je zou hebben moeten zien dat zodra er een fout optreedt (in dit geval het toewijzen van een getal aan een string variabele) het programma stopt en de regels code na de fout niet worden uitgevoerd, zelfs als deze wel juist zijn.

Exception handling is het proces van het opvangen van de exceptions die worden geworpen om ervoor te zorgen dat het script blijft werken.

Exception handling wordt gedaan door middel van een try-catch block.

Het CATCH block kan worden gedefinieerd op dezelfde manier als een given block. Dat betekent dat we verschillende soorten van exceptions kunnen opvangen en afhandelen.

Naast het vangen van exceptions, laat Raku het ook toe om een exception expliciet te werpen.
Man kan twee soorten van exceptions werpen:

Ad-hoc exceptions worden geworpen door de die subroutine gevolgd door het bericht van de exception.

Getypeerde exceptions zijn objecten, daarom moeten we de .new() constructeur gebruiken in bovenstaand voorbeeld.
Alle getypeerde exceptions erven van de klasse X , hieronder zie je een paar voorbeelden:
X::AdHoc is het simpelste exception type
X::IO is gerelateerd aan IO fouten
X::OS is gerelateerd aan OS fouten
X::Str::Numeric wordt geworpen bij een fout in het veranderen van een string naar een getal.

Een reguliere expressie kan als volgt worden gedefinieerd:

Tenzij het specifiek wordt aangeduid, is witruimte zonder betekenis, dus m/licht/ en m/ licht / zijn hetzelfde.

Alphanumerieke karakters en het liggend streepje _ mogen als zichzelf worden geschreven.
Alle andere karakters moeten speciaal worden behandeld door er een backslash \\ voor te plaatsen of door ze te omgeven door aanhalingstekens.

Karakters kunnen worden geclassificeerd in categorieën en ook daarmee kunnen we vergelijken.
We kunnen ook vergelijken met de inverse van een categorie (alle karakters behalve degene in die categorie).

Het vergelijken van categorieën van karakters zoals we in de vorige sectie zagen, is erg gemakkelijk.
Maar wellicht is het gebruik van Unicode eigenschappen een meer systematische aanpak.
Unicode eigenschappen worden omgeven door <: >

Jokers (wildcards) kunnen ook in een regex worden gebruikt.

De punt . betekent elk enkel karakter.

Factoren (quantifiers) komen na een karakter en worden gebruikt om aan te geven hoe vaak we dat karakter verwachten.

Het vraagteken ? betekent nul of één keer.

De asterisk * betekent nul of meer keer.

Het plusteken + betekent tenminste één keer.

Elke keer wanneer het vergelijken van een string met een regex succesvol is, wordt het resultaat in een speciale variable $/ geplaatst.

$/ geeft een Match Object terug (de string die gevonden is door de regex)
Deze methoden kunnen worden aangeroepen op een Match Object:
.prematch geeft de string vóór de gevonden string terug.
.postmatch geeft de string na de gevonden string terug.
.from geeft de positie van het eerste karakter van de gevonden string terug.
.to geeft de positie nà het laatste karakter van de gevonden string terug.

Laten we eens kijken of een emailadres goed is of niet.
Voor dit voorbeeld zullen we aannemen dat een werkend emailadres wordt gevormd door:
voornaam [punt] achternaam [bij] bedrijfsnaam [punt] top-niveau (e.g. nl)

jan.met@raku.org lijkt een valide emailadres

<:L> accepteert een enkele letter
<:L>` accepteert één of meer letters + `\.` accepteert een enkele [punt] + `\@` accepteert een enkel @-karakter + `<:L:N> accepteert één of meer letters gevolgd door een cijfer
<:L+:N>+ accepteert één of meer letters + cijfer één of meer keer

De regex kan als volgt uit elkaar worden gehaald:

Een regex op naam wordt als volgt gedefinieerd: my regex regex-naam { regex definitie }
Een regex op naam kan als volgt worden aangeroepen: <regex-naam>

MD5 is een cryptografische functie die een unieke 128bit waarde (hash) produceert.
MD5 heeft een grote variëteit van applicaties waarvan het opslaan van wachtwoorden in een database er één is. Zodra een nieuwe gebruiker zich registreert, worden de inloggegevens niet als platte tekst opgeslagen, maar als een hash. Het idee daarachter is dat in het geval dat een database wordt gestolen, de dief dan niet zal kunnen weten wat de wachtwoorden zijn.

Laat ons een script schrijven dat een MD5 hash van een wachtwoord maakt voordat het in een database wordt opgeslagen.

Gelukkig is er al een Raku module geimplementeerd voor het MD5 algoritme. Laten we het eerst installeren:
zef install Digest::MD5

Voer daarna onderstaand script uit:

Om de md5_hex() functie, die de hashes aanmaakt, aan te kunnen roepen moeten we eerst de benodigde module laden.
Het use sleutelwoord laadt een module voor gebruik in het script.

Bovenstaande 3 regels laten verschillende manieren zien om een karakter op te bouwen:

De letter á kan worden geschreven als:

NFC geeft het unieke codepoint.
NFD haalt het karakter uit elkaar en geeft de codepoints van elk onderdeel.
uniname geeft de naam van de codepoint.

Onder normale omstandigheden worden alle taken in een programma achter elkaar uitgevoerd.
Dit hoeft niet noodzakelijkerwijs een probleem te zijn tenzij wat je probeert te doen een hoop tijd vergt.

Natuurlijk heeft Raku een aantal mogelijkheden die het mogelijk maken om delen van een programma parallel uit te laten voeren.
Op dit moment is het belangrijk om op te merken dat parallelisme twee dingen kan betekenen:

Laten we beginnen met de laatste.

Bekijk hier het C-programma dat een functie definieert met de naam hallovanc. Deze functie drukt de string Hallo van C af op het scherm. Het ontvangt geen parameters, en het geeft ook geen enkele waarde terug.

Afhankelijk van het Operating System dat je gebruikt, moet je de volgende commando’s uitvoeren om een bibliotheek te maken van bovenstaand C programma.

Maak vervolgens een bestand aan met het volgende Raku programma, in dezelfde directory waar je de C-bibliotheek hebt gecompileerd. En voer dat programma dan uit.

Ten eerste gaven we aan dat we de NativeCall module wilden gebruiken.
Vervolgens maakten we een constante LIBPATH aan waarin de locatie van de C-bibliotheek staat.
Merk op dat $*CWD de huidige directory aangeeft. Vervolgens maakten we een nieuwe Raku subroutine hallovanc die als een verpakking functioneert van de functie met dezelfde naam in de C-bibliotheek die aangegeven wordt door LIBPATH.
Dit alles wordt gedaan door het gebruik van de is native eigenschap.
Tot slot roepen we de Raku subroutine aan.

Uiteindelijk komt het er op neer dat we een subroutine hebben gedefinieerd met de is native eigenschap, en het aangeven van de naam van de C-bibliotheek.

Zojuist hebben we gezien dat we een simpele C-functie kunnen aanroepen door deze te verpakken in een Raku subroutine met dezelfde naam door het gebruik van de is native eigenschap.

In sommige gevallen willen we dat name van de Raku subroutine anders is.
Dat kun je doen door het gebruik van de is symbol eigenschap.

Laten we bovenstaand Raku programma aanpassen en de Raku subroutine de naam hallo geven in plaats van hallovanc.

In de situatie waarin de Raku subroutine een andere naam heeft als de naam van de functie aan de C-kant, kun je de is symbol eigenschap gebruiken met de naam van de C-functie.

Compileer deze aangepaste C-bibliotheek en voer dan het onderstaande Raku programma uit.
Merk op dat we zowel de C-bibliotheek als het Raku programma zo hebben aangepast dat ze beide een string verwachten (char* in C, en Str in Raku).

Laten we dit nog eens doen zodat het resultaat wordt teruggegeven van een simpele berekening die twee gehele getallen optelt.
Compileer de C-bibliotheek en voer het Raku programma uit.

Merk op dat zowel de C-functie als de Raku subroutine nu 2 gehele getallen verwachten (int in C, en int32 in Raku).

Je zult je wellicht hebben afgevraagd waarom we int32 hebben gebruikt in plaats van Int in dit laatste voorbeeld.
Sommige Raku typen, zoals Int, Rat, etc., kunnen niet worden gebruikt om waarden naar een C-functie te sturen, of waarden van een C-functie terug te ontvangen.
Men moet in Raku dezelfde typen gebruiken als die in C worden gebruikt.

Gelukkigerwijze bestaan er vele types in Raku die overeenkomen met types zoals die in C worden gebruikt.