rust armanriazi generic
Rust Generics
In Rust, generics allow you to write code that can work with different types. This helps in creating reusable and flexible code. Generics are defined using angle brackets (<>
) and can be used with functions, structs, and enums.
Here's an example of a generic function in Rust:
fn print<T>(value: T) {
println!("Value: {}", value);
}
In this example, the print
function takes a generic type T
as a parameter and prints its value. The type T
can be any type that implements the Display
trait.
To use the print
function with a specific type, you can explicitly specify the type when calling the function:
print::<i32>(42); // Prints: Value: 42
print::<String>("Hello, Rust!"); // Prints: Value: Hello, Rust!
You can also use type inference to let the compiler determine the type:
print(42); // Prints: Value: 42
print("Hello, Rust!"); // Prints: Value: Hello, Rust!
Generics can also be used with structs and enums. Here's an example of a generic struct:
struct Pair<T> {
first: T,
second: T,
}
In this example, the Pair
struct has two fields of the same generic type T
. This allows you to create a Pair
instance with any type that implements the Copy
trait:
let pair = Pair { first: 42, second: 24 };
let string_pair = Pair { first: "Hello", second: "Rust" };
You can also define multiple generic types in a single declaration:
struct Tuple<T, U> {
first: T,
second: U,
}
In conclusion, generics in Rust provide a way to write code that can work with different types, making it more flexible and reusable. They can be used with functions, structs, and enums, allowing you to create generic algorithms and data structures.