Cargo en je eerste programma

Rust is een gecompileerde taal: je schrijft broncode, de compiler (rustc) maakt er een uitvoerbaar programma van. In de praktijk roep je rustc bijna nooit zelf aan. Je gebruikt Cargo: het bouwprogramma en de pakketbeheerder van Rust in één. In deze les installeer je alles, maak je je eerste project, en leer je de foutmeldingen van de compiler lezen: die worden je beste vriend.

Installeren

De officiële manier is rustup, een installatieprogramma dat ook updates regelt.

• macOS en Linux: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
• Windows: download rustup-init.exe van rustup.rs. Je hebt ook de "Visual Studio C++ Build Tools" nodig; het installatieprogramma helpt daarbij.

Controleer daarna:

rustc --version
cargo --version

Bijwerken doe je later met rustup update. Installeer in je editor de extensie rust-analyzer: die laat fouten zien terwijl je typt en vult code aan.

Een project aanmaken

cargo new hallo
cd hallo

Cargo maakt deze structuur:

hallo/
├── Cargo.toml       projectgegevens en afhankelijkheden
├── .gitignore
└── src/
    └── main.rs      je code

Cargo.toml:

[package]
name = "hallo"
version = "0.1.0"
edition = "2024"

[dependencies]

De edition bepaalt welke versie van de taalregels geldt. Nieuwe editions verschijnen eens per drie jaar; oude code blijft werken.

src/main.rs:

fn main() {
    println!("Hallo, wereld!");
}

• fn main() is het startpunt van elk programma.
• println! drukt een regel af. Het uitroepteken betekent dat het een macro is, geen gewone functie. Voor nu: macro's herken je aan de !; in les 28 zie je hoe ze werken.
• Elke opdracht eindigt met ;.

Bouwen en draaien

cargo run

   Compiling hallo v0.1.0 (/home/jij/hallo)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/hallo`
Hallo, wereld!

cargo run compileert als dat nodig is en start het programma. Andere commando's:

Het programma in target/release/hallo is een zelfstandig bestand: je kunt het naar een andere computer met hetzelfde besturingssysteem kopiëren en daar draaien, zonder Rust te installeren.

Variabelen en opmaak

fn main() {
    let naam = "Sanne";
    let leeftijd = 34;
    println!("{naam} is {leeftijd} jaar.");
    println!("{} is {} jaar.", naam, leeftijd);
    println!("Prijs: €{:.2}", 3.5);
}

Sanne is 34 jaar.
Sanne is 34 jaar.
Prijs: €3.50

{naam} zet de variabele direct in de tekst. {} vult de argumenten op volgorde in. {:.2} toont twee decimalen. Meer over variabelen in les 3.

Foutmeldingen lezen

Maak bewust een fout: vergeet een aanhalingsteken.

error[E0765]: unterminated double quote string
 --> src/main.rs:2:14
  |
2 |     println!("Hallo, wereld!);
  |              ^^^^^^^^^^^^^^^^^

Een Rust-foutmelding heeft altijd:

1. Een code (E0765). rustc --explain E0765 geeft een uitgebreide uitleg met voorbeelden.
2. De plek: bestand, regel en kolom.
3. Vaak een suggestie (help: …) die precies vertelt wat je kunt veranderen.

De Rust-compiler is streng, maar zijn foutmeldingen zijn uitzonderlijk behulpzaam. Lees ze helemaal, van boven naar beneden; los de eerste fout eerst op, want volgende fouten zijn er vaak het gevolg van.

Een kassabon

fn main() {
    let brood = 2.49;
    let kaas = 4.15;
    let melk = 1.09;
    let totaal = brood + kaas + melk;

    println!("{:<10}{:>8.2}", "Brood", brood);
    println!("{:<10}{:>8.2}", "Kaas", kaas);
    println!("{:<10}{:>8.2}", "Melk", melk);
    println!("{}", "-".repeat(18));
    println!("{:<10}{:>8.2}", "Totaal", totaal);
}

Brood         2.49
Kaas          4.15
Melk          1.09
------------------
Totaal        7.73

{:<10} lijnt links uit over 10 tekens, {:>8.2} rechts over 8 met twee decimalen.

Typische fouten

• Puntkomma vergeten: expected ';'. De melding wijst naar de plek.
• println zonder !: cannot find function println; de compiler stelt println! voor.
• cargo run in de verkeerde map: could not find Cargo.toml. Ga naar de projectmap.
• Enkele aanhalingstekens voor tekst: 'hallo' is in Rust een fout; 'a' is één teken (char), tekst gebruikt "…".

Oefeningen

1. Wat is het verschil tussen cargo build en cargo build --release?
2. Laat je programma je naam en woonplaats in één zin afdrukken, met {}-opmaak.
3. Voeg aan de kassabon een regel "BTW 9%" toe, berekend over het totaal.

Lab: hallo-wereld en een kassabon in Rust

Samenvatting

• Installeer met rustup; Cargo bouwt, draait en beheert afhankelijkheden.
• cargo new, cargo run, cargo build --release, cargo check.
• fn main() is het startpunt; println! is een macro met opmaak als {}, {naam}, {:.2}.
• Lees foutmeldingen helemaal; de compiler geeft vaak de oplossing.

Volgende les: variabelen, waarom ze standaard niet veranderen, en de typen van Rust.