Functies in Rust lijken sprekend op functies in C, maar met een paar belangrijke verschillen. Op GitHub staat een klein programmaatje dat een paar kerngedachten illustreert.

Om te beginnen is het nuttig te bedenken dat in Rust, net als in C, je altijd de functie main hebt. Dat is waar elk programma begint. Verder mag je functies definiëren waar je wil, zolang ze maar zichtbaar zijn in de scope waarbinnen je ze aanroept. Logische plekken zijn dus voor, of na main.

De vorm van iedere functie is

fn functie() {
     codeblock
}

voor een functie zonder argumenten en zonder return-waarde. Als je wel argumenten wil gebruiken dan benoem je die binnen de eerste () en je moet dan ook het type opgeven. Meerdere argumenten mag, door deze te scheiden met een komma. Als je wil dat een functie een return-waarde heeft, dan geef je het type op direct na de (), met een ->. Zo krijg je als begin van een functie die een integer met 1 verhoogt:

fn inc(x: i32) -> i32 {

Je kan de returnwaarde opgeven zoals in C met het commando return, maar in Rust is de laatste waarde in een codeblock, mits niet afgesloten met een puntkomma, altijd de returnwaarde van dat codeblock. Zo wordt de hiervoor genoemde functie in “C stijl” dus

fn inc(x: i32) -> i32 {
     return x + 1;
}

maar mooier, meer “Rust”, is

fn inc(x : i32) -> i32 {
     x + 1
}

Beide zijn goed, de laatste is iets mooier.

Let op dat ik zei: de laatste waarde is de returnwaarde van een codeblock. Dus ook buiten een functie. Zo kan je y als volgt de waarde van x+5 meegeven:

let y = {
     let x = 10;
     x + 5
}

Immers, x+5 is de laatste waarde, er volgt geen puntkomma, en dus is x+5 de returnwaarde van dit codeblock. Of dat handig is, daar mag je over twisten. Immers, de x in dit codeblock heeft een levensduur tot het einde van het codeblock. Zodra y de waarde van x+5 krijgt, wordt x zelf vernietigd.

In het programmaatje op GitHub wordt dat gebruikt om het principe van shadowing nog eens te laten zien. Buiten het codeblock wordt een mutable x gedefinieerd, die in de schaduw komt van de immutable x binnen het codeblock, maar die zodra deze x uit scope raakt weer uit de schaduw tevoorschijn komt.
Dat is allemaal heel leuk, en het geeft inzicht in hoe Rust met variabelen om gaat, maar het levert niet direct er leesbare code op.

Wie mee wil doen met #klooienmetcomputers kan dat doen via GitHub. Maak een account op www.github.com en zoek naar Abmvk/kmc. Het account Abmvk volgen kan ook. Lezers zijn vrij te gebruiken wat ze willen en om zelf zaken toe te voegen of aan te passen, vragen te stellen of commentaar te leveren.