mirror of
https://github.com/darkicewolf50/RustBrock.git
synced 2025-06-16 05:24:17 -06:00
303 lines
8.8 KiB
Markdown
303 lines
8.8 KiB
Markdown
# Generic Data Types
|
|
These are used to create definitions for items like function signatures or structures, where it is then used with many different concrete data types
|
|
|
|
## In Function Definitions
|
|
|
|
When defining a function that uses generics, yo place the generics in the signature of the funct.
|
|
|
|
This is usually in the place where concrete data types are specified (the parameters and return type)
|
|
|
|
This makes code more flexible and provide more functionality whilst preventing code duplication
|
|
|
|
Continuing with the finding the largest num in a `i32` vector slice and a `char` vector slice
|
|
|
|
```rust
|
|
fn largest_i32(list: &[i32]) -> &i32 {
|
|
let mut largest = &list[0];
|
|
|
|
for item in list {
|
|
if item > largest {
|
|
largest = item;
|
|
}
|
|
}
|
|
|
|
largest
|
|
}
|
|
|
|
fn largest_char(list: &[char]) -> &char {
|
|
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_i32(&number_list);
|
|
println!("The largest number is {result}");
|
|
|
|
let char_list = vec!['y', 'm', 'a', 'q'];
|
|
|
|
let result = largest_char(&char_list);
|
|
println!("The largest char is {result}");
|
|
}
|
|
```
|
|
|
|
Here is the code before the use of generics
|
|
|
|
Notice the repeated code for a both types of slices
|
|
|
|
To parameterize the types in a signle function, the first thing is to name the type parameter (just like with concrete types)
|
|
|
|
You can use any identifier as a type parameter name but it is common to use `T`
|
|
|
|
Type parameter names in Rust are short, often just one letter and Rust's type-maning convention is UpperCamelCase
|
|
|
|
The `T` is the default choice of most Rust programmers
|
|
|
|
To use a generic it needs to be declared before it can be used
|
|
|
|
To delcare is place it inside `<>` and between the name of the function and the parameter list
|
|
|
|
Example
|
|
```rust
|
|
fn larget<T>(list: &[T]) -> &T {}
|
|
```
|
|
|
|
This function is read as: the function `largest` is generic over some type `T`. This function has one parameter named `list`, which is a slice of values of type `T`. The `largest` function will return a reference to a value fo the same type `T`.
|
|
|
|
Here is the updated, **but this code will not compile**
|
|
```rust
|
|
fn largest<T>(list: &[T]) -> &T {
|
|
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 char_list = vec!['y', 'm', 'a', 'q'];
|
|
|
|
let result = largest(&char_list);
|
|
println!("The largest char is {result}");
|
|
}
|
|
```
|
|
Here is the compilation error you will get
|
|
```
|
|
$ cargo run
|
|
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
|
|
error[E0369]: binary operation `>` cannot be applied to type `&T`
|
|
--> src/main.rs:5:17
|
|
|
|
|
5 | if item > largest {
|
|
| ---- ^ ------- &T
|
|
| |
|
|
| &T
|
|
|
|
|
help: consider restricting type parameter `T`
|
|
|
|
|
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
|
|
| ++++++++++++++++++++++
|
|
|
|
For more information about this error, try `rustc --explain E0369`.
|
|
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error
|
|
```
|
|
This mentions ```std::cmp::PartialOrd```, thisis a *trait*.
|
|
|
|
For now know that this error states that the body of largest won't work for all possible types that `T` could be, becasue you cant compair against all possible values that `T` could be
|
|
|
|
To enable comparisions, the std library has the `std::cmp::PartialOrd` tait that you can implement on types.
|
|
|
|
By following the help text's usggestion you can restrict the types vaild for `T` to only those that implement `PartialOrd`, then this example will compile, becuase of the restriction that the std library implements `PartialOrd` on both `i32` and `char`
|
|
|
|
## In Struct Definitions
|
|
This can also be in a structure the generic also has to be defined in `<>` with the `T` being inside
|
|
|
|
Here is an example
|
|
```rust
|
|
struct Point<T> {
|
|
x: T,
|
|
y: T,
|
|
}
|
|
|
|
fn main() {
|
|
let integer = Point { x: 5, y: 10 };
|
|
let float = Point { x: 1.0, y: 4.0 };
|
|
}
|
|
```
|
|
This is similar to function definitions, after the generic is defined it can be used in the body
|
|
|
|
Note the use of only one generic type, this forces the use of only one concrete type when used in the entirity of the body
|
|
|
|
Here is a disallowed initialization
|
|
```rust
|
|
struct Point<T> {
|
|
x: T,
|
|
y: T,
|
|
}
|
|
|
|
fn main() {
|
|
let wont_work = Point { x: 5, y: 4.0 };
|
|
}
|
|
```
|
|
This is not allowed bacuse you are trying to assign both an `i32` and a folating point integer, the struct definition does not allow this basue to only accpets one type per instance
|
|
|
|
You could use two generics in the definition
|
|
|
|
Here is an example where the use above would be allowed
|
|
```rust
|
|
struct Point<T, U> {
|
|
x: T,
|
|
y: U,
|
|
}
|
|
|
|
fn main() {
|
|
let both_integer = Point { x: 5, y: 10 };
|
|
let both_float = Point { x: 1.0, y: 4.0 };
|
|
let integer_and_float = Point { x: 5, y: 4.0 };
|
|
}
|
|
```
|
|
Notice that `x` and `y` can now both be different concrete types.
|
|
|
|
You can use as many generic type parameters in a definition as wanted but more than a few makes it hard to read the code.
|
|
|
|
If you need lots of generic tpyes in your code, it indicates that yor code need restructing into smaller pieces
|
|
|
|
## In Enum Definitions
|
|
Just like structs, it can also be used in enums.
|
|
|
|
An example that was used in the past was `Option<T>`
|
|
|
|
Here is an example in the form of the ``Result` enum that was unsed before sa well
|
|
```rust
|
|
enum Result<T, E> {
|
|
Ok(T),
|
|
Err(E),
|
|
}
|
|
```
|
|
|
|
The `Result` enum has two generics which typically hold the sucess value and an error type
|
|
|
|
If you recognize situations in your code with multiple struct or enum definitions that differ only in the types of the values they hold, thne you can avoid duplication by using generic types
|
|
|
|
## In Method Definitions
|
|
You can implement generics in the associate methods of structs as well
|
|
|
|
Here is an example that uses the example form the Structures Section
|
|
```rust
|
|
struct Point<T> {
|
|
x: T,
|
|
y: T,
|
|
}
|
|
|
|
impl<T> Point<T> {
|
|
fn x(&self) -> &T {
|
|
&self.x
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let p = Point { x: 5, y: 10 };
|
|
|
|
println!("p.x = {}", p.x());
|
|
}
|
|
```
|
|
|
|
Not hat you have to delcare `T` right after `impl` so that we can use `T` to specify that we are implementing meothds on tpye `Point<T>`
|
|
|
|
By declaring `T` as a generic type after `impl`, Rust can identify that the type in the angle brackets in `Point` is a generic type rather than a concerete type.
|
|
|
|
You can choose a differnet nmae fo the generic than the original definition in the struct, using the same name is the standard
|
|
|
|
Methods written in that `impl` that delcares the generic will also be definined in any method in that `impl` scope no matter what concrete type is used in the definition
|
|
|
|
We can also specifiy constraints on generic types when deining methods on the type
|
|
|
|
For example lets say you have methods that you only want on `Point<f32>` instances rather than on `Point<T>` instances with a generic type
|
|
|
|
Here is an example of this
|
|
```rust
|
|
impl Point<f32> {
|
|
fn distance_from_origin(&self) -> f32 {
|
|
(self.x.powi(2) + self.y.powi(2)).sqrt()
|
|
}
|
|
}
|
|
```
|
|
|
|
Ths code means the tpye `Point<f32>` will have a `distance_from_origin` method and other methods of `Point<T>` that is not a `f32`
|
|
|
|
This method measures how far way the point is away from the coordinates (0.0, 0.0) and uses operations that are only available for floating-point types
|
|
|
|
Generic type parameters in a stuct def arent always the same as those you use in you in the same struct's methods signatures
|
|
```rust
|
|
struct Point<X1, Y1> {
|
|
x: X1,
|
|
y: Y1,
|
|
}
|
|
|
|
impl<X1, Y1> Point<X1, Y1> {
|
|
fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
|
|
Point {
|
|
x: self.x,
|
|
y: other.y,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let p1 = Point { x: 5, y: 10.4 };
|
|
let p2 = Point { x: "Hello", y: 'c' };
|
|
|
|
let p3 = p1.mixup(p2);
|
|
|
|
println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
|
|
}
|
|
```
|
|
This is used for deep copies where you dont know if the generic is the same as the original struct
|
|
|
|
This is an ample to show a situation where is is possible and used
|
|
|
|
It also shows how in the case that you need it
|
|
|
|
## Perfomance of Code Using Generics
|
|
There is no cost at runtime for uing generics
|
|
|
|
Rust accomplishes this by performing monomorphization of the code using generics at compile time
|
|
|
|
*Monomorphization* is the proccess of turing generic code into specific code by filling in the concrete types that are used when complied
|
|
|
|
The compiler does the opposite of the steps we used o create the generic function
|
|
|
|
Here is an illustration of what the complier would do, just with different names
|
|
```rust
|
|
enum Option_i32 {
|
|
Some(i32),
|
|
None,
|
|
}
|
|
|
|
enum Option_f64 {
|
|
Some(f64),
|
|
None,
|
|
}
|
|
|
|
fn main() {
|
|
let integer = Option_i32::Some(5);
|
|
let float = Option_f64::Some(5.0);
|
|
}
|
|
``` |