How do you create and use generic functions and types in Rust?

In Rust, generics enable the creation of functions and types that can handle multiple data types while maintaining type safety. Using generics enhances code flexibility and reusability.

Creating Generic Functions

To define generic functions in Rust, you can specify one or more generic type parameters after the function name using angle brackets <>. These type parameters can be utilized in the function's parameter list and return type. Here is a simple example:

rust
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

In this example, the largest function determines the maximum value in a list where elements implement the PartialOrd and Copy traits. It enforces these trait bounds to ensure elements can be compared and copied.

Creating Generic Data Types

Generics can also be used to define structs, enums, or other types. Here is an example of a Point struct definition using generics:

rust
struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }

    fn new(x: T, y: T) -> Self {
        Point { x, y }
    }
}

This Point struct can store x and y coordinates of any type, provided both coordinates are of the same type. By declaring the generic type T with <T> after the struct keyword, we can leverage it within the struct definition.

Using Generic Types

Once generic functions or types are defined, you can instantiate them with concrete types. Here is an example of using the Point struct and the largest function:

rust
fn main() {
    let integer_point = Point::new(5, 10);
    let float_point = Point::new(1.0, 2.0);

    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);
}

In this example, we create two instances of the Point type: one using integers and another using floating-point numbers. Additionally, we use the largest function to find the maximum values in integer and character lists.

Summary

Generics are one of Rust's powerful features, enabling the development of more flexible and general-purpose code. Understanding and effectively utilizing generics is a crucial step for becoming an efficient Rust developer.