Antwoord.

Generieke types (generics) stellen je in staat om code te schrijven die onafhankelijk is van een specifiek type. Ze worden geïmplementeerd met behulp van de syntaxis van hoekige haken:

fn max<T: PartialOrd>(a: T, b: T) -> T {
  if a > b { a } else { b }
}

Hier is T een generiek type, beperkt door de trait PartialOrd.

Generic parameters worden verklaard met <T>, maar kunnen worden beperkt met trait bounds door middel van een dubbele punt, bijvoorbeeld <T: Display>. Dit is een manier om de compiler te informeren dat alleen die types waarvoor de benodigde trait is geïmplementeerd, kunnen worden gebruikt.

In Rust worden er twee vormen van dispatch geïdentificeerd voor generics:

• Monomorfisatie: code genereert tijdens de compileertijd aparte varianten van de functie/struct voor elk gebruikt type. Dit gebeurt door het absorberen van trait bounds.
• Dynamische dispatch: als dyn Trait wordt gebruikt, gebeurt de aanroep via een virtuele tabel (vtable).

Invloed op de machinecode: Het gebruik van generics met trait bounds (zonder dyn Trait) leidt tot monomorfisatie: een toename van de binaire bestandsgrootte, maar met maximale snelheid. Het gebruik van dyn Trait bespaart binaire ruimte, maar heeft een prestatieverlies.

Vraag met een valstrik.

Vraag: Is er een functie

fn do_something<T: Debug>(value: &T)

Zal de compiler een aparte functie do_something in de binaire code creëren voor elk type waarmee deze wordt gebruikt, of zal hij een universele implementatie gebruiken?

Typisch foutief antwoord: Er wordt één functie voor alle types gebruikt dankzij de trait bound.

Juiste antwoord: De compiler creëert aparte kopieën van deze functie voor elk type (monomorfisatie), omdat de trait bound de generieke functie niet 'universaal' maakt via vtable. Universalisme verschijnt alleen bij dyn Trait (dynamische dispatch).

Voorbeeld:

fn print_val<T: std::fmt::Debug>(val: T) {
    println!("{:?}", val);
}
// Voor elke aanroep met een ander type wordt een eigen versie van de functie gemaakt

Voorbeelden van echte fouten door gebrek aan kennis van de fijne kneepjes van het onderwerp.

---

Verhaal

In een project met grote generieke objecten werd ontdekt dat het binaire bestand aanzienlijk groter was dan verwacht. Later bleek dat de oorzaak het brede gebruik van generieke functies zonder beperkingen was. Aanroepen met tientallen types leidden tot een exponentiële toename van de uitvoerbare bestandsgrootte (code bloat), wat alleen tijdens de release-build op CI werd vastgesteld.

---

Verhaal

Een van de ontwikkelaars nam een generieke parameter met een trait bound aan, in de veronderstelling dat deze code werkte met 'dynamische' dispatch. Dit leidde tot geheugenverspilling op de server en verminderde prestaties door de constante groei van code en het cachen ervan door de processor.

---

Verhaal

In de bibliotheek werd geprobeerd om een generieke trait met een Self-type (bijvoorbeeld, trait Clone) te gebruiken als dyn Trait, wat niet wordt ondersteund in Rust en leidde tot een compileerfout. De interface moest expliciet worden herschreven, anders zou de generieke API niet in dynamische modus werken, en de interface zou op compile-tijd moeten worden gewijzigd.