Rust: Traits and Generics

Rust is an extremely fast programming language that supports speed, concurrency, as well as multithreading. In Rust, we have a concept of Traits and Generics where Generics are an abstraction of various properties, and Traits are used for combining generic types for constraining types for accepting particular behaviour of various types.

Real-Life Examples of Traits and Generics

Let’s say you have a Printer trait. It might have a print() method. Now, you can implement this trait for a Book, Document, or even a Spreadsheet. All you need to know is that these types have a print() method—they might do it differently, but as long as they stick to the contract, you’re good to go.

Defining and Implementing Traits

trait Printer {
    fn print(&self);
}

Implementing Traits in Rust

struct Book {
    title: String,
}

impl Printer for Book {
    fn print(&self) {
        println!("Printing book: {}", self.title);
    }
}

• This defines a structure named Book.It has a single field, title, which is of type String. This field will store the title of the book.
• This block implements the Printer trait for the Book structure.
• Traits in Rust are similar to interfaces in other languages. They define a set of methods that a type must implement to be considered compatible with that trait.
• The Printer trait (which we assume is defined elsewhere) likely has a print method, and this implementation provides the specific behavior for the Book type.
• The print method takes a reference to the Book instance (&self) and prints the book’s title to the console using println!.

Combining Trait Bounds and Generics

fn print_item<T: Printer>(item: T) {
    item.print();
}

• The print_item function provides a generic way to print any item that implements the Printer trait.
• This means you can use the same function to print different types of objects, as long as they have a print method that follows the Printer trait’s definition.

Output