#klooienmetcomputers

Compound types

Arnout van Kempen over rommelen in een digitale wereld.

De 'normale' types hebben we de vorige keer bekeken. Die zijn redelijk simpel: een variabele heeft één waarde, van een bepaald type. Meestal kan je daarmee rekenen, of andere enkelvoudige operaties mee uitvoeren. Niet heel anders dan in C. Uit C kennen we ook wat ingewikkelder structuren, zoals arrays, structs en unions. In Rust is dat niet anders. Een vorm die op de struct uit C lijkt, is de tuple. Een tuple is in feite niets anders dan een groep waarden, met ieder hun eigen type, die samengebracht zijn in één variabele.

Een simpel voorbeeld, waarbij de compiler exact de types van de delen van de tuple meekrijgt is:

let voorbeeld_tuple: (i32, i32, bool) = (10, 20, true);

De individuele waarden van de tuple uitlezen kan op verschillende manieren. Zo kun je alle velden ineens toekennen aan andere variabelen. Hier is het niet nodig opnieuw types aan te geven, omdat die al vaststaan door de tuple-definitie. Zo krijg je de waarden met:

let (a, b, c) = voorbeeld_tuple;

maar je kan de waarden ook individueel uitlezen met een index, startend bij 0:

 let b2 = voorbeeld_tuple.1;

Op GitHub heb ik dit in een programmaatje gedaan. Als je dat compileert, ontdek je een bijzonder aardige eigenschap van de Rust compiler. Omdat ik a, b, c en b2 een waarde geef, maar b vervolgens niet gebruik, geeft de compiler een warning. Dat is geen error en dus kan de compiler gewoon het programma verwerken, maar het is toch nuttig om even naar te kijken. De warning geeft exact aan wáár het probleem ontstaat, wat de vermoedelijke oorzaak is en hoe je het kan oplossen: je definieert een variabele b zonder dat je daarmee iets doet.

Een bijzondere tuple wordt in Rust ook wel een unit genoemd, dat is een lege tuple. Die heeft de vorm () en kan je bijvoorbeeld gebruiken als type voor een functie zonder return-waarde. In het programmaatje op GitHub zie je dat in de functie-definitie fn print_hello() -> (). De uitkomst van deze functie is dus een unit, een lege tuple, dus eigenlijk 'niets'.

Arrays in Rust lijken sprekend op arrays in C. Als het type van de array duidelijk is voor de compiler, is het niet nodig een type toe te voegen, zoals in array1 die duidelijk uit strings bestaat. Wil je wel een type toevoegen, dan geef je meteen aan hoeveel waarden de array zal bevatten. Zoals in let array2: [f64; 3] = [1.0, 2.0, 3.0];

Tenslotte kan je ook een array vullen met dezelfde waardes. Wil je een array met tien nullen, dan maak je die met let array3 = [0; 10];

In het programmaatje op GitHub doe ik verder weinig spannends met deze waarden, behalve ze afdrukken. Denk er daarbij aan dat de macro println!(“dit werkt wel {a}”); werkt omdat je enkelvoudige variabelen tussen de accolades kan zetten, maar dat enkel het uitrekenen van de index van een array al rekenwerk is en dat moet in de macro buiten de accolades gebeuren. Dus println!(“dit werkt niet {a[1]}”); println!(“dit wel {}”,a[1]);

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.

Arnout van Kempen di CCO CISA is Senior manager Risk & Compliance bij Baker Tilly. Hij schrijft op persoonlijke titel. Hij is lid van de Commissie Financiële verslaggeving & Accountancy van de AFM en lid van de signaleringsraad van de NBA. Daarnaast is hij diaken van het bisdom 's-Hertogenbosch.

Gerelateerd

reacties

Reageer op dit artikel

Spelregels debat

    Aanmelden nieuwsbrief

    Ontvang elke werkdag (maandag t/m vrijdag) de laatste nieuwsberichten, opinies en artikelen in uw mailbox.

    Bent u NBA-lid? Dan kunt u zich ook aanmelden via uw ledenprofiel op MijnNBA.nl.