Rust kan vrij goed overweg met multi-threaded programmeren. Dat betekent dat je stukken code tegelijk, naast elkaar, kan laten werken. Handig voor nogal complexe zaken, dus voor een later moment. Maar het levert ook een toepassing op die al iets minder complex is: Je kan Rust aan het werk zetten om code te testen. Wat je dan doet, is aan Rust vertellen welke functies je wil testen, en Rust zal deze functies in een eigen thread laten lopen. Als de functie fout loopt en in een panic! eindigt, loopt je programma gewoon door, maar krijg je aan het eind een net overzicht welke test-functies goed verlopen zijn, welke in een panic! eindigden en waarom. Heel handig! Maar nog steeds wat complexer dan waar we nu mee bezig zijn, dus ik ga nog een stap simpeler: de assert-macro’s van Rust.

In C konden we vrij aardig debuggen door op slimme plaatsen variabelen te printen en dan maar hopen dat je ziet wat waar mis gaat. In Rust kan dat ook, maar je kan daarnaast een handige macro gebruiken die ook nog eens prettig leesbaar is in je code. Bedenk wel dat de code die we hiervoor gebruiken echt bedoeld is voor debug-doeleinden. Enkele weken geleden ging het over error-handling. Daar gaat het om het afwikkelen van fouten die je als programmeur hebt voorzien. Bijvoorbeeld een functie om een bestand te openen, die er rekening mee houdt dat actie nodig is als dat bestand niet blijkt te bestaan.

Bij debugging draait het om fouten in je code, dus fouten die je niet hebt voorzien. Natuurlijk kan je error-handling en debugging door elkaar gebruiken, maar leesbaarder wordt het daar niet van.

Rust kent drie macro’s die specifiek handig zijn in debugging: assert!(boolean), assert_eq!(T, T), assert_ne!(T, T). Alle drie zijn nog uit te breiden met een foutboodschap.

Assert!( a == b) doet niets als a en b gelijk zijn. Zijn ze ongelijk, dus als de boolean waarde die aan de macro wordt meegegeven false is, dan volgt een panic!.
Bij assert_eq! en assert_ne! worden de twee argumenten van hetzelfde type vergeleken. Voldoen ze aan de verwachting (equal, of juist not equal) dan gebeurt er niets. En anders opnieuw: panic! 

Stel je voor dat je weet dat Pi gelijk is aan 22/7 en in je code maak je daar gebruik van. Maar ergens loopt het toch niet lekker. Neem de navolgende, op zich onzinnige code:

use std::f64::consts;

fn main() {
    let resultaat = 22.0 / 7.0;
    if resultaat == consts::PI {
        println!(“Pi = 22/7”);
    }
}

Met de eerste use brengen we alle floating point constanten die Rust standaard kent in scope. Een van die constanten is PI. Aangezien we er van overtuigd zijn dat 22/7 == Pi, is het onbegrijpelijk dat dit programma weliswaar werkt, maar niet de boodschap afdrukt dat Pi = 22/7. 

Nu zouden we hier eenvoudig aan kunnen toevoegen println!(“resultaat = {}”, resultaat); maar met de assert-macro bereiken we dat we niet worden lastig gevallen met informatie, zolang het programma doet wat we verwachten en dat het programma stopt als niet aan onze verwachtingen is voldaan. En als we dan extra informatie willen, kan dat ook. Door deze toevoeging bereiken we precies wat we willen: 

assert!( resultaat == consts::PI, “resultaat = {}\nPI is {}”, resultaat, consts::PI);

Wie mee wil doen met #klooienmetcomputers kan dat doen via GitHub. Maak een account op 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.