generics, traits, lifetimes, Rust programming language, code

Working with Generic Types, Traits, and Lifetimes

In Rust, generics are used to provide flexibility when writing code. Generic types allow for abstracting behavior across multiple different types, while traits help to make our code more reusable by allowing for shared functionality and lifetimes determines how long a variable can last for. In this article, we’ll look at these three elements in more detail and go over how to use them.

Generic Types

Generic types are used when you want to write a function or type that can work with multiple different types. For example, you could write a generic function that takes two arguments and returns their sum like so:

fn add(a: T, b: T) -> T {
    a + b
}

Here, we specified the type T as a generic parameter. We can now call this function with any type that implements addition, such as i32:

let result = add(5, 10);
assert_eq!(result, 15);

Generic types can also be used when defining types. For example, we can define a generic stack type that can store elements of any type like so:

struct Stack {
    items: Vec,
}

Traits

Traits are Rust’s way of sharing common behavior between types. A trait describes the behavior that’s expected from a type, which allows us to write code that works with any type that implements that trait. For example, the std::cmp::PartialOrd trait describes types that have an ordering, such as integers and floats. This means that we can write code that will work with any type that implements the PartialOrd trait, such as i32 and f32:

fn max(a: T, b: T) -> T {
    if a > b {
        a
    } else {
        b
    }
}

let result = max(5, 10);
assert_eq!(result, 10);

Lifetimes

Finally, lifetimes determine how long a variable is valid. This is especially important when dealing with references since Rust needs to know when the reference should no longer be valid. For example, when returning a reference from a function, we have to specify the lifetime of the reference using a lifetime parameter:

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

Here, we specified the lifetime 's as a parameter. This tells Rust that the returned reference must be valid for at least as long as the reference passed in. With lifetimes, we can make sure that references are always valid, which is essential for safety.

In summary, generic types, traits, and lifetimes are some of the most important concepts in Rust. Generic types allow us to write code that works with multiple types, while traits help us share common behavior. Lifetimes ensure that references remain valid while our program is running.