If you are interested in exploring more Rust topics, check our Rust list to learn more.
The <T> Parameter
When declaring generic types, you will find the <T> parameter. It is a used to represent any data type in Rust:
An example of the type parameter in a function is a shown:
The above defines a generic function that takes an argument T of any type.
You can define multiple generic parameters by separating them with commas:
In the above syntax, we define multiple generic parameters, T, U, V. Although not required, it is common to find generic types starting from T and incrementing up the alphabet.
Rust Define Generic Struct
We can define a generic struct as shown in the syntax below:
// struct info
}
Take the example, struct defined below:
i: T,
j: U,
}
fn main() {
let var1 = MyStruct{
i: 10,
j: "Hi"
};
println!("X: {}", var1.i);
println!("Y: {}", var1.j);
}
The above creates a generic struct with two parameters. Inside the struct, we specify two struct members of type T and U. Since T and U are generic types, they can be of any type.
Generic Functions
The same construct can be applied to functions and method. If a function takes type <T>, it is said to be a generic function.
Generic function definition is as shown:
// function logic
}
Take the example of generic function definition below:
println!("{}", var);
}
fn main() {
generic("Hi")
}
In this example, we have a generic function that takes any type and prints it to the console. However, running the above code will cause an error.
Since we are using a generic parameter, we need to implement the display or debug trait to print it out. We can refine the code as:
fn generic<T: Debug>(var: T) {
println!("{:?}", var);
}
fn main() {
generic("Hi")
}
In this case, we import the debug trait and use it for the generic type. We can then print the value using the debug trait placeholder: {:?}
The same case applies if a function needs to perform any kind of operation. Take the example function below that returns 0 if a value is even and 1 if otherwise.
if var % 2 == 0 {
return 0;
} else {
return 1;
}
}
If we call the function above, it will return an error. We need to implement the Rem trait for it to work as:
use std::cmp::Eq;
fn even_odd<T: Rem<Output = T> + Eq> (var: T) -> i32 {
The Rem and Eq traits allow you to use the remainder operator and perform logical comparison.
Conclusion
In this article, we explored the fundamentals of working with generic types in the Rust language. Check the docs to learn more.
