Raku Inleiding

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

Er zijn een aantal manieren om Raku te installeren.

Je kunt eenvoudig Raku code uitvoeren in de REPL (Read-Eval-Print-Loop, oftewel een lees, evalueer, print, lus). Open daarvoor een terminalvenster, type raku 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 raku bestandsnaam.raku in het terminalvenster 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 terminalvenster, door raku -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.

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:

Punt-komma’s zijn niet nodig na de laatste opdracht in een bestand of een blok programma-code, maar het is een goed gebruik om ze dan in dat geval toch toe te voegen.

Een Blok kan bestaan uit nul of meer opdrachten. Je maakt een blok door accolades om de opdrachten heen te plaatsen.

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

Expressies bestaan uit Termen en Operatoren.

Termen zijn:

Operatoren worden onderverdeeld in deze typen:

Onderstaande tabel toont de meest voorkomende operatoren.

Logische operatoren combineren condities of kunnen kiezen tussen 2 waarden aan de hand van een conditie.

Logische operatoren worden meestal gebruikt om meerdere vergelijkingen te combineren.

De gedefinieerd-of operator // is een gemakkelijke manier of verstek waarde aan te geven.

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.

Hieronder vind je nog een paar voorbeelden van operaties die op een array kunnen worden uitgevoerd:

@dieren[*-1] geeft het laatste element van een array.
@dieren[0, 1] geeft meerdere elementen in één keer. Dit heet een plak (slice).
.join(', ') geeft een enkele string gemaakt door alle elementen, gescheiden door een komma en een spatie, samen te voegen.
.unshift() voegt één of meer elementen toe aan het begin van een array.
.shift verwijdert het eerste element van een array en geeft dat terug.

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.

Een string gedefineerd met dubbele aanhalingstekens vervangt de variabelen met hun waarde.
Dit wordt "interpolatie" genoemd.

Interpolatie is niet beperkt tot variabelen. Elk stuk programma code dat omgeven wordt door accolades zal worden uitgevoerd, en het resultaat daarvan wordt in de string geplaatst.

De laatste string werd gemaakt met enkele aanhalingstekens, waarin niets wordt geïnterpoleerd.

A list of words can be written without quotes and without commas, by enclosing it in angle brackets.

Is een kortere manier van schrijven dan:

Op een string kunnen vele methoden worden aangeroepen, zoals hieronder is te zien:

.chars geeft het aantal karakters in de string.
.uc en .lc geeft de string in hoofdletters of kleine letters.
.flip geeft de string met de karakters achterstevoren.
.contains() geeft aan of een string in de string voorkomt.
.starts-with() en .ends-with() geeft aan of een string begint of eindigt met een andere string.
.substr(a, b) geefts b karakters beginnend op positie a.
.index() geeft de positie van een string in een andere string.
.trim geeft een string zonder de witruimte aan begin en einde van de string

Een string kan worden gespleten in een lijst, en een lijst kan worden samengevoegd tot een string.

.words splijt een string in woorden.
.join() combineert de gegeven lijst in een string met de gegeven separator tussen de elementen.
.split() splijt een string op de gegeven separator.
.comb geeft een lijst met elke letter van de string apart..

sprintf bouwt een string naar aanleiding van het gegeven sjabloon.
Het sjabloon bevat formatteer aanduidingen die beginnen met %. Elke aanduiding wordt vervangen door een van de waarden die worden meegegeven.

%s geeft een string aan.
%d geeft een geheel getal (integer) aan.
%.2f geeft een getal afgerond op 2 decimalen aan.
%05d geeft een geheel getal, uitgevuld tot 5 posities.

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.

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.

De while lus herhaalt executie van een blok zolang de conditie waar is.

until is tegenovergestelde versie van while. Het herhaalt het blok zolang de conditie niet waar is.
Dat is te vergelijken met unless.

Bovenstaand voorbeeld kan ook worden geschrene als

next en last geven ons meer controle over een lus. Ze kunnen worden gebruikt in een for, loop, while en until lus.

next unless $number %% 2 negeert de getallen die niet door 2 deelbaar zijn
last if $number > 8 stopt de lus zodra de waarde meer is dan 8, dus 10 zal nooit getoond worden.

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.

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:

De parameters die we tot nu toe hebben gezien, worden "positionele parameters" genoemd. Arguments worden toegekend aan parameters door hun positie: het eerst argument gaat naar de eerste parameter, het tweede argument naar de tweede parameter, en zo verder.

Een parameter die toegewezen wordt aan de hand van een naam, heet een "genoemde parameter".

Since the arguments are matched by name, they can be supplied in any order. Omdat de argument per naam toegekend worden aan de parameter, maakt het niet uit in welke volgorde ze worden gespecificeerd.

Een subroutine kan ook een variabel aantal argumenten opvangen in een slurpende parameter.
Een slurpende parameter is een array specificatie na een asterisk, zoals *@namen. Het verzamelt alle overige (positionele) argumenten.

We hebben eerder al gezien dat een parameter beperkt kan worden tot een type, zoals Str $naam.
Het kan nog verder worden beperkt door het sleutelwoord where toe te voegen, gevolgd door een conditie.

De eerste aanroep is succesvol. De tweede niet omdat 15 weliswaar een Int is, maar die waarde voldoet niet aan de conditie.

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.

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 een lijst waaroin 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).

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 functionele 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 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.

Alle code objecten in Raku zijn zogenaamde "omsluitingen" (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 omsluiting (closure) geworden.

Een omsluiting 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.

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 genoemde argumenten.
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 positionele argumenten accepteert.

We hebben eerder al gezien dat een subroutine niet aangeroepen kan worden zonder een van haar parameters. De standaard constructor gedraagt zich anders: een attribuut waarvoor geen genoemd argument is meegegeven in een aanroep aan .new() blijft simpelweg gezien leeg.

Net als met parameters aan een subroutine, is het mogelijk om een verstekwaarde aan een attribuut toe te kennen.
Like the parameters of a subroutine, an attribute can be given a default value.
Dit gebeurt door een toewijzing aan te geven bij de definitie. Andersom, als er altijd een genoemd argument moet worden gegeven voor een attribuut, dan kan dat worden aangeven met de sleutelwoorden is required

The nationaliteit van $jan werd niet aangegeven, dus werd de verstekwaarde gebruikt.
$niemand kon niet worden gemaakt omdat het genoemde argument naam ontbrak.

Methoden zijn de subroutines van een object.
Zij zijn, net als subroutines, een manier om een aantal functies te bundelen, ze accepteren argumenten, hebben een signatuur en kunnen worden gedefinieerd als multi.

Je definieert een methode met het method sleutelwoord.
Normaal gesproken zijn methoden nodig om bepaalde acties op de attributen van een object uit te voeren. Dit bekrachtigt het concept van inkapseling. De attributen van een object kunnen alleen worden gemanipuleerd vanaf binnen de klasse van het object door gebruik van methoden. De buitenwereld kan alleen maar gebruik maken van de methoden van het object en heeft geen toegang tot de attributen van het object.

Door een methode te definiëren in een klasse, kun je deze aanroepen op een object met de punt notatie:
object . methode of als in bovenstaand voorbeeld: $jan.bepaal-geschiktheid