Antwoord

In Rust worden constante expressies (const) geëvalueerd tijdens de compilatie, waardoor waarden worden gecreëerd die deel uitmaken van het programma vóór de uitvoering. Dergelijke expressies worden gebruikt voor het definiëren van array-groottes, waarden in statische structuren, generic parameters en andere situaties waar onveranderlijke constanten met een hard gecodeerde waarde vereist zijn.

In Rust kunnen "const" functies (const fn) worden gemaakt, die kunnen worden gebruikt binnen andere const-expressies of om constante variabelen te initialiseren. De compiler garandeert dat een dergelijke expressie geen ongeldige bewerkingen bevat (bijvoorbeeld geheugen toegang).

Voorbeeld:

const fn fib(n: u32) -> u32 {
    match n {
        0 | 1 => 1,
        _ => fib(n - 1) + fib(n - 2),
    }
}

const F8: u32 = fib(8);
const ARR: [u32; F8 as usize] = [0; F8 as usize]; // Array met grootte 34

In dit voorbeeld worden de waarde F8 en de grootte van de array ARR tijdens de compilatie geëvalueerd.

Bedrieglijke Vraag

Wat is het verschil tussen een const functie en een gewone functie, en kan elke functie als const fn worden gedeclareerd?

Antwoord: Nee, niet elke functie kan als const fn worden gedeclareerd. const fn mag alleen goedgekeurde bewerkingen bevatten die geen bijeffecten of werken met onveilige geheugen bevatten. Bijvoorbeeld, het is niet toegestaan om een bestand te openen of geheugen dynamisch te alloceren in const fn.

const fn add(x: i32, y: i32) -> i32 {
    x + y // toegestaan
}

// maar dit zal niet compileren:
const fn fail() -> String { // fout!
    String::from("err")
}

Voorbeelden van echte fouten door onbekendheid met de nuances van dit onderwerp

---

Verhaal

In een project probeerden ze de hashwaarde van een string tijdens de compilatie te berekenen via een constante functie, maar ze gebruikten binnen deze functie standaardmethoden uit HashMap en geheugenallocatie. Het programma compileerde niet en gaf onduidelijke fouten over ongeldige bewerkingen in const fn.

---

Verhaal

In grote embedded-ontwikkeling definieerde een ontwikkelaar een constante structuur met velden die berekening tijdens de compilatie vereisen, maar hij gebruikte binnen de initialisatie een functie uit een externe crate die niet gemarkeerd was als const fn. Dit leidde tot het onvermogen om deze logica te gebruiken voor het bepalen van de groottes van statische buffers.

---

Verhaal

In de code hebben ze het verschil tussen static en const verward, terwijl ze probeerden om een "constante" tijdens de uitvoering te wijzigen en kregen impliciete UB (Undefined Behavior), aangezien constanten in Rust niet in het geheugen worden geplaatst als waarden, maar door de compiler op de plek van gebruik worden vervangen, wat hun wijziging helemaal niet mogelijk maakt.