Rust Interview Questions

In Rust, traits are a way to define shared behavior across different types. They are similar to interfaces in other languages, such as Java and C#. Traits allow you to specify a set of methods that implementing types must provide. Traits are a powerful feature of Rust that enable polymorphism and code reuse.

Defining Traits

A trait is defined using the trait keyword. Within the trait, you define the methods that must be implemented by any type that wants to implement the trait.

Example of a Trait Definition

trait Greet {
    fn greet(&self) -> String;
}

In this example, the Greet trait has a single method, greet, which takes a reference to self and returns a String.

Implementing Traits

To implement a trait for a type, you use the impl keyword followed by the trait name for the type.

Example of Implementing a Trait

struct Person {
    name: String,
}

impl Greet for Person {
    fn greet(&self) -> String {
        format!("Hello, my name is {}!", self.name)
    }
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
    };
    println!("{}", person.greet());
}

In this example, the Person struct implements the Greet trait by providing an implementation of the greet method.

Using Traits

Once a trait is implemented for a type, you can use trait methods on instances of that type. Traits can also be used to define generic functions and bounds.

Example of Using Trait Methods

fn print_greeting<T: Greet>(g: T) {
    println!("{}", g.greet());
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
    };
    print_greeting(person);
}

In this example, the print_greeting function is generic over any type T that implements the Greet trait. It can call the greet method on any such type.

Default Implementations

Traits can provide default implementations for methods. Types that implement the trait can override these default methods if needed.

Example of Default Implementations

trait Greet {
    fn greet(&self) -> String {
        String::from("Hello!")
    }
}

struct Person {
    name: String,
}

impl Greet for Person {
    fn greet(&self) -> String {
        format!("Hello, my name is {}!", self.name)
    }
}

struct Dog;

impl Greet for Dog {}

fn main() {
    let person = Person {
        name: String::from("Alice"),
    };
    let dog = Dog;

    println!("{}", person.greet()); // Custom implementation
    println!("{}", dog.greet());    // Default implementation
}

In this example, the Dog type uses the default implementation of the greet method, while the Person type provides its own implementation.

Trait Objects

Trait objects allow for dynamic dispatch of trait methods. They are useful when you want to work with different types that implement the same trait but don’t know the specific types at compile time.

Example of Trait Objects

fn greet_all(greeters: Vec<&dyn Greet>) {
    for greeter in greeters {
        println!("{}", greeter.greet());
    }
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
    };
    let dog = Dog;

    let greeters: Vec<&dyn Greet> = vec![&person, &dog];
    greet_all(greeters);
}

In this example, greet_all takes a vector of trait objects (&dyn Greet). It can call the greet method on any type that implements the Greet trait, without knowing the specific types at compile time.

Summary

• Traits: Define shared behavior across different types, similar to interfaces in other languages.
• Defining Traits: Use the trait keyword to define a trait with method signatures.
• Implementing Traits: Use the impl keyword to implement a trait for a specific type.
• Using Traits: Call trait methods on instances of types that implement the trait. Use traits to define generic functions and bounds.
• Default Implementations: Provide default method implementations in traits that can be overridden by implementing types.
• Trait Objects: Enable dynamic dispatch by using trait objects (&dyn Trait), allowing you to work with different types that implement the same trait.

Traits are a fundamental part of Rust’s type system and enable powerful abstractions and code reuse. They allow you to define and use common behavior in a flexible and type-safe manner.