Boeken
Rust
Hoofdstuk 5. Goede Programmeerpraktijken
Refactoring

Rust:
Refactoring

Hoe:

Laten we een eenvoudig stukje Rust-code refactoren om het meer idiomatisch en onderhoudbaar te maken. We beginnen met een functie die de som berekent van een vector van integers:

fn sum(vec: &Vec<i32>) -> i32 {
    let mut sum = 0;
    for i in vec {
        sum += i;
    }
    sum
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    println!("De som is {}", sum(&numbers));
}

Output:

De som is 15

Nu, laten we dit refactoren om meer idiomatisch Rust te gebruiken door iterators en de fold methode te gebruiken:

fn sum(vec: &[i32]) -> i32 {
    vec.iter().fold(0, |acc, &x| acc + x)
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    println!("De som is {}", sum(&numbers));
}

Geen verandering in output - het is nog steeds 15 - maar de gerefactoreerde versie is schoner en gebruikt de sterke punten van Rust zoals lenen en iterator methoden.

Diepgaand onderzoek

Refactoren heeft zijn wortels in de Smalltalk-gemeenschap en werd populair gemaakt in de Java-wereld door Martin Fowlers boek “Refactoring: Improving the Design of Existing Code”. De principes zijn universeel en gelden ook voor Rust, waar veiligheid en gelijktijdigheid van het grootste belang zijn. Rust moedigt het schrijven van robuuste code aan door problemen tijdens de compilatietijd te vangen, dus tijdens het refactoren fungeert de Rust-compiler als een veiligheidsnet.

Alternatieven voor handmatig refactoren omvatten het gebruik van geautomatiseerde hulpmiddelen, zoals ‘rustfmt’ voor code-opmaak en ‘clippy’ voor linting, die meer idiomatische manieren van coderen kunnen suggereren. Echter, diepgaand refactoren vereist vaak een doordacht begrip van het ontwerp van de code, wat deze tools niet volledig kunnen automatiseren.

In Rust kan refactoren draaien rond het verbeteren van het gebruik van typen, effectief gebruikmaken van levensduur, het verminderen van onnodige toewijzingen, of het toepassen van gelijktijdigheidspatronen zoals het gebruik van Arc<Mutex<T>> wanneer nodig. Het is ook gebruikelijk om over te gaan van unwrap() naar expressievere foutafhandeling met Result<T, E>.

Zie ook

Om verder te duiken in refactoren in Rust:

Code organiseren in functies