mirror of
https://github.com/darkicewolf50/RustBrock.git
synced 2025-07-25 20:36:00 -06:00
.github
.obsidian
HelloWorld
branches
functions_rust
guessing_game
hello_cargo
loops
ownership
rectangles
.gitignore
Collection of Common Data Structs.md
Constants.md
Crates.md
Data Types.md
Enums.md
Error Handling.md
Generic Types Traits and Lifetimes.md
Generics.md
Hash.md
Modules and Use.md
Packages.md
Paths.md
Primitives.md
Project Organization.md
README.md
Reducing Code Duplication.md
RustBrock.code-workspace
String.md
Structures.md
Variables.md
Vector.md
data_types.md
ownership.md
82 lines
2.6 KiB
Markdown
82 lines
2.6 KiB
Markdown
# Removing Duplcation by Extracting a Function
|
|
Generics allow us to replace specific tpyes with a placeholder that represents multiple values
|
|
|
|
Lets look at how to remove duplication in a way that doesnt invlove generic types by extracting a function that replaces specific values with a generics.
|
|
|
|
By being able to recognize duplicated code you can extract into a funct, you can start to recognize duplicated code that use generics
|
|
|
|
Lets look at some code that finds the largest number in a list
|
|
```rust
|
|
fn main() {
|
|
let number_list = vec![34, 50, 25, 100, 65];
|
|
|
|
let mut largest = &number_list[0];
|
|
|
|
for number in &number_list {
|
|
if number > largest {
|
|
largest = number;
|
|
}
|
|
}
|
|
|
|
println!("The largest number is {largest}");
|
|
|
|
let number_list = vec![102, 34, 6000, 89, 54, 2, 43, 8];
|
|
|
|
let mut largest = &number_list[0];
|
|
|
|
for number in &number_list {
|
|
if number > largest {
|
|
largest = number;
|
|
}
|
|
}
|
|
|
|
println!("The largest number is {largest}");
|
|
}
|
|
```
|
|
|
|
Although it owrks, duplicated code is tedious and error prone, also you have to update the code in multiple places when we want to change it
|
|
|
|
To eliminate duplication you can create an abstraction by defining a function that operates on any list of integers passed in as a parameter
|
|
|
|
This makes our code clearer
|
|
|
|
Here is the same code by extracted into a function that finds the largest number in a `i32` list
|
|
|
|
```rust
|
|
fn largest(list: &[i32]) -> &i32 {
|
|
let mut largest = &list[0];
|
|
|
|
for item in list {
|
|
if item > largest {
|
|
largest = item;
|
|
}
|
|
}
|
|
|
|
largest
|
|
}
|
|
|
|
fn main() {
|
|
let number_list = vec![34, 50, 25, 100, 65];
|
|
|
|
let result = largest(&number_list);
|
|
println!("The largest number is {result}");
|
|
|
|
let number_list = vec![102, 34, 6000, 89, 54, 2, 43, 8];
|
|
|
|
let result = largest(&number_list);
|
|
println!("The largest number is {result}");
|
|
}
|
|
```
|
|
|
|
The parameter of the `largest` function called `list` represents any concrete slice of `i32` values that might be passed into the funct
|
|
|
|
Here are the steps taken to change the code from the original to the second with the abstracted function:
|
|
1. Identify duplicate code
|
|
1. Extract the duplicated code into a function, and specify the inputs and return values of that code in the funct signature
|
|
1. Update the two instances of dplicated code to make a call to the funct instead
|
|
|
|
We can use these smae steps with generics to reduce code duplication, in the same way the fnction body can operate on an abstract `list` instead of specific values
|
|
|
|
Generics allow code to operate on abstract types
|
|
|