Generieke code schrijven in Rust
Leer functies en gegevensstructuren schrijven die met meerdere typen werken, zodat u code kunt hergebruiken zonder typeveiligheid op te offeren.
Generieke code schrijven in Rust is een gratis Leer programmeren met Rust-les op CoddyKit. Dit is les 1 van 3. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Leer programmeren met Rust. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Leer programmeren met Rust bevat in totaal 3 lessen.
Waarom generieke code schrijven?
Stel dat je een functie nodig hebt die het grootste item in een lijst vindt. Wat als je deze nodig hebt voor getallen, daarna voor tekens en vervolgens voor aangepaste objecten?
Zonder generieke typen zou je voor elk type een aparte functie schrijven, wat tot veel dubbele code leidt. Dit is waar generieke typen van pas komen!
Generieke typen introduceren
Met generieke typen kun je code schrijven die met meerdere typen werkt, zonder jezelf te herhalen. Ze bieden een manier om flexibele en herbruikbare functies of gegevensstructuren te schrijven.
Je kunt het zien als een bouwplan dat aan verschillende materialen kan worden aangepast.
Je eerste generieke functie
Om een functie generiek te maken, declareer je typeparameters tussen punthaken <> achter de functienaam. Een veelgebruikte naam voor een typeparameter is T (van Type).
Deze functie print_anything kan nu elk type afdrukken!
fn print_anything<T>(item: T) {
println!("The item is: {}", item);
}
pub fn main() {
print_anything(5);
print_anything("hello");
print_anything(true);
}Typeparameters uitgelegd
De <T> in fn print_anything<T>(item: T) betekent dat T een tijdelijke aanduiding voor een type is. Wanneer je de functie aanroept met een i32, wordt T i32.
- Typeparameters: generieke typen krijgen meestal namen met hoofdletters, zoals
T,UenV. - Flexibiliteit: de compiler bepaalt tijdens het compileren het concrete type.
Gedrag toevoegen: trait-beperkingen
Soms moet de typeparameter T van je generieke functie specifiek gedrag hebben. Als je bijvoorbeeld twee Ts wilt vergelijken, moet T vergelijkbaar zijn.
We voegen trait-beperkingen toe om deze vereisten vast te leggen. Hier betekent T: PartialOrd + Copy dat T de traits PartialOrd (gedeeltelijke ordening voor vergelijkingen) en Copy moet implementeren.
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
let mut largest = list[0];
for &item in list.iter() {
if item > largest {
largest = item;
}
}
largest
}
pub fn main() {
let number_list = vec![34, 50, 25, 100, 65];
println!("Largest number: {}", largest(&number_list));
let char_list = vec!['y', 'm', 'a', 'q'];
println!("Largest char: {}", largest(&char_list));
}Syntaxis voor meerdere trait-beperkingen
Je kunt meerdere traits voor een generiek type vereisen met de syntaxis +, zoals T: TraitA + TraitB.
Voor complexe beperkingen kun je ook een where-clausule na de functiesignatuur gebruiken. Hierdoor kan de signatuur overzichtelijker worden:
fn some_function<T, U>(t: T, u: U) -> i32 where T: Display + Clone, U: Clone + Debug { /* ... */ }
Generieke structs
Net als functies kun je structs generiek maken voor een of meer typeparameters. Hierdoor kunnen je gegevensstructuren gegevens van elk opgegeven type bevatten.
De struct Point<T> kan coördinaten van elk type T bevatten (bijvoorbeeld i32 en f64).
struct Point<T> {
x: T,
y: T,
}
pub fn main() {
let integer_point = Point {
x: 5,
y: 10
};
let float_point = Point {
x: 1.0,
y: 4.0
};
println!("Int Point: ({}, {})",
integer_point.x, integer_point.y);
println!("Float Point: ({}, {})",
float_point.x, float_point.y);
}Methoden implementeren voor generieke structs
Wanneer je methoden voor een generieke struct implementeert, moet je de generieke typeparameter(s) na impl opgeven.
Je kunt ook trait-beperkingen aan methoden toevoegen als een methode specifiek gedrag van de generieke typen vereist.
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
pub fn main() {
let p = Point {
x: 5,
y: 10
};
println!("p.x = {}", p.x());
}Generieke typen en prestaties
Een van de sterke punten van Rust is dat generieke typen een abstractie zonder kosten vormen. Dit betekent dat het gebruik van generieke typen geen nadelige invloed heeft op de prestaties tijdens runtime.
Rust bereikt dit via monomorfisatie: tijdens het compileren genereert de compiler gespecialiseerde versies van je generieke code voor elk concreet type waarmee deze wordt gebruikt. Zo worden largest<i32> en largest<char> twee afzonderlijke, geoptimaliseerde functies.
Test je kennis
Welke van de volgende uitspraken over generieke typen in Rust zijn JUIST?
Samenvatting: de kracht van generieke typen
In deze les heb je de basis geleerd van het schrijven van generieke code in Rust:
- Wat ze zijn: een manier om flexibele, herbruikbare code te schrijven.
- Generieke functies:
<T>gebruiken voor typeparameters. - Trait-beperkingen: vereist gedrag opgeven met
T: Trait. - Generieke structs: gegevensstructuren maken die generieke typen bevatten.
- Zonder runtimekosten: de generieke typen van Rust worden gecompileerd naar specifieke code, zonder nadelige invloed op de prestaties tijdens runtime.
Generieke typen vormen een hoeksteen van idiomatische Rust en maken krachtige, typeveilige abstracties mogelijk!
Leer Rust met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 39
- Lessen
- 144
Veelgestelde vragen
Is de les “Generieke code schrijven in Rust” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer programmeren met Rust, waaronder “Generieke code schrijven in Rust”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Leer programmeren met Rust bevat in totaal 3 lessen.
Wat leer ik in “Generieke code schrijven in Rust”?
Leer functies en gegevensstructuren schrijven die met meerdere typen werken, zodat u code kunt hergebruiken zonder typeveiligheid op te offeren. Je oefent met Leer programmeren met Rust door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Leer programmeren met Rust te beginnen?
Ervaring vooraf is niet nodig. Leer programmeren met Rust op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 3.
Hoe lang duurt de les “Generieke code schrijven in Rust”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Leer programmeren met Rust?
Ja. Elke les over Leer programmeren met Rust bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Generieke code schrijven in Rust
- Traits definiëren en implementeren
- Geavanceerd gebruik van traits: associated types