Rust is zoals dat heet statically typed, wat zoveel wil zeggen als dat de compiler moet weten welke type iedere variabele heeft. Als je daar even over nadenkt, is dat eigenlijk nogal logisch; bij C zagen we hetzelfde. En waarom is dat zo logisch? Bedenk dat de compiler je programma omzet naar machinecode die voor de computer direct leesbaar is. Die code zal de computer hoe dan ook gaan uitvoeren. Daarvoor moet die computer dus wel weten wat moet worden gedaan.

Laten we een theoretisch voorbeeldje nemen. Stel dat je een taal hebt waarin je het type van een variabele kan veranderen gedurende de uitvoering van het programma, dus niet zoiets als type-casting waarbij je al in je programma het type van een variabele aanpast. Dan weet de compiler immers al wat je aan het doen bent. Nee, we nemen het theoretische voorbeeld, in een niet bestaande ‘dynamically typed’ taal waarbij een variabele zich moet aanpassen vanwege user input. Stel dat je zoiets zou hebben:

integer var;
input(var);
print(1/var);

Ook al voer je een integer in in de variabele var, om de reciproque te berekenen zal var wel moeten veranderen in een float. Behalve als je 1 invoert, dan kan var een integer blijven en is de uitkomst ook een integer.

Op het niveau van de machinecode heeft dat forse gevolgen. Immers, voor een integer reserveert de computer bijvoorbeeld 2 of 4 bytes, maar voor een float zijn veel meer bytes nodig (zie de eerdere aflevering over types in C). Moet de compiler hier voor de zekerheid maar vast ruimte maken voor een float? Maar dat is gek, waarom kan je de variabele dan definiëren als een integer? En zoals we eerder gezien hebben, computers rekenen feilloos met integers, maar niet met floats. Dus als de programmeur die exactheid nodig heeft, elders? Wat moet de compiler hier mee?

Het antwoord is heel simpel: dynamically typed talen bestaan wel (zoals Python, JavaScript min of meer en Ruby) maar als je ze goed bekijkt valt dat toch wat tegen. Zo lost Python bovenstaand probleem min of meer op door bij input() gewoon altijd een string te lezen. De programmeur moet dan zelf maar regelen dat de input naar een variabele van het juiste type wordt omgezet. Zo kan iedereen wel dynamisch zijn.

Rust volgt de logica die ook C kent en zet die tot in het redelijk extreme door zelfs. In Rust moet je heel exact aangeven welk type een variabele heeft, tenzij voor de compiler geen enkele twijfel kan bestaan. De enige uitzondering is het type i32. Omdat dit zo vaak toch gekozen wordt en het een mooie balans is tussen bruikbaarheid en geheugenbeslag, zal de compiler als duidelijk is dat we een integer bedoelen, maar niet welke exact, kiezen voor i32.
Buiten dat type, en dus de volstrekt evidente types, hebben we maar aan te geven welk type een variabele heeft. En de keuze is, meer nog dan bij C, vrij overweldigend. Omdat Rust echt heel exact wil weten wat we van plan zijn.

De mogelijkheden van de scalars, dus de ‘schaal-waardes’, in Rust zijn:

Integers, signed (i) of unsigned (u), met daarna het aantal bits. Dat levert i8, u8, i16, u16, i32, u32, i64, u64, i128, u128. En als extra nog isize en usize. Deze laatste twee zijn afhankelijk van je computer. Op een 32-bits computer zijn deze formaten hetzelfde als i32, u32 en op een 64-bits computer i64, u64.

De constanten mag je in ieder normaal talstelsel schrijven, dus decimaal, hexadecimaal, octaal en binair. Een u8-variabele kan nog een ‘byte’ constante krijgen.
Bijzonder aan decimalen is dat ze geen prefix krijgen zoals de andere talstelsels (0x voor hex, 0o voor octaal en 0b voor binair). En vrij bijzonder is dat rust de underscore gebruikt in getallen, zoals Amerikanen een komma en wij een punt. Dat betekent dat in Rust een miljard geschreven kan worden als 1_000_000_000. Je mag dat bijvoorbeeld ook in een binair getal doen om de bytes uit elkaar te houden. Dus ook dit is een bruikbare notatie: 0b1101_1100_0101_1111

Er is nog een specifieke schrijfwijze voor een byte, altijd van type u8: je kan dan de ASCII-code krijgen door het ASCII-teken tussen enkele aanhalingstekens te plaatsen. Zo is b’A’ gelijk aan 65, omdat de ASCII-code voor de letter A 65 is.

Naast integers kent Rust natuurlijk floats. Dit zijn f32 en f64. Floats in 32 bits of in 64 bits. Op een normaal systeem gebruik je altijd f64, omdat je nauwkeurigheid en grootte dan het grootst zijn en een modern systeem probleemloos met 64-bits floats overweg kan.

Net als in C kan je de basisberekeningen uitvoeren in Rust. Bij delen krijg je een float als uitkomst als je floats deelt en bij integers krijg je een integer (met a/b) en de rest, ook een integer (met a%b).

Een volgend type is bool, ook geen onbekende na C. Dit type kent als waardes true, false.

Als laatste scalar kent Rust het type char, dat lijkt op wat we uit C kennen, maar het is toch anders. Een char in Rust is niet 1 maar 4 bytes groot en kan dus veel meer informatie kwijt dan alleen ASCII-karakters. Rust gebruikt de karakterset ‘Unicode’, waarin naast ASCI-codes ook de Europese accenten zitten, Chinese, Japanse en Koreaanse karakters, emoji’s et cetera.

Naast de scalars kent Rust de compound-types, maar daarover de volgende keer meer.  

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.