Implementing traits in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of trait method call with default implementation

What is the output of this Rust code?

Rust

trait Greet {
    fn greet(&self) {
        println!("Hello from trait!");
    }
}

struct Person;

impl Greet for Person {}

fn main() {
    let p = Person;
    p.greet();
}

A Runtime error: method not found

B Compilation error: missing method implementation

C Hello from trait!

D No output

💡 Hint

Check if the trait method has a default implementation.

The trait Greet provides a default implementation for greet. Since Person implements Greet but does not override greet, the default method is called, printing "Hello from trait!".

❓ Predict Output

intermediate

Output when trait method is overridden

What will this Rust program print?

Rust

trait Speak {
    fn speak(&self) {
        println!("Speaking from trait");
    }
}

struct Dog;

impl Speak for Dog {
    fn speak(&self) {
        println!("Woof!");
    }
}

fn main() {
    let d = Dog;
    d.speak();
}

A Woof!

B Runtime error: method not found

C Compilation error: conflicting implementations

D Speaking from trait

💡 Hint

Look at whether the trait method is overridden in the implementation.

The Dog struct overrides the speak method from the Speak trait, so calling d.speak() prints "Woof!".

🔧 Debug

advanced

Why does this trait implementation cause a compilation error?

Identify the cause of the compilation error in this Rust code.

Rust

trait Calculate {
    fn calculate(&self, x: i32) -> i32;
}

struct Calculator;

impl Calculate for Calculator {
    fn calculate(&self, x: i32) -> i32 {
        42
    }
}

fn main() {
    let c = Calculator;
    println!("{}", c.calculate(10));
}

A Method signature in impl does not match trait definition

B Missing semicolon after method body

C Trait method cannot return a value

D Struct Calculator does not implement the trait

💡 Hint

Compare the method signatures in the trait and the implementation.

The trait Calculate requires a method calculate(&self, x: i32) -> i32. The implementation defines calculate(&self) without the parameter x, causing a signature mismatch and compilation error.

📝 Syntax

advanced

Which option correctly implements a trait for a generic struct?

Given the trait Displayable and a generic struct Wrapper<T>, which implementation is syntactically correct?

Rust

trait Displayable {
    fn display(&self) -> String;
}

struct Wrapper<T> {
    value: T,
}

A

impl Displayable for Wrapper<T> {
    fn display(&self) -> String {
        format!("Value: {:?}", self.value)
    }
}

B

impl<T> Displayable for Wrapper<T> {
    fn display(&self) {
        println!("Value: {:?}", self.value);
    }
}

C

impl<T> Displayable for Wrapper {
    fn display(&self) -> String {
        format!("Value: {:?}", self.value)
    }
}

D

impl<T> Displayable for Wrapper<T> {
    fn display(&self) -> String {
        format!("Value: {:?}", self.value)
    }
}

💡 Hint

Remember to include generic parameters in both impl and trait implementation.

Option D correctly uses impl<T> Displayable for Wrapper<T> and returns a String as required. Option D misses generic parameter T in impl. Option D misses <T> after Wrapper. Option D has wrong return type (missing String return).

🚀 Application

expert

What is the output of this trait object usage?

Consider this Rust code using trait objects. What will it print?

Rust

trait Animal {
    fn sound(&self) -> &'static str;
}

struct Cat;
struct Dog;

impl Animal for Cat {
    fn sound(&self) -> &'static str {
        "Meow"
    }
}

impl Animal for Dog {
    fn sound(&self) -> &'static str {
        "Woof"
    }
}

fn make_sound(animal: &dyn Animal) {
    println!("{}", animal.sound());
}

fn main() {
    let cat = Cat;
    let dog = Dog;
    let animals: Vec<&dyn Animal> = vec![&cat, &dog];
    for a in animals {
        make_sound(a);
    }
}

A Woof\nMeow

B Meow\nWoof

C Compilation error: cannot create trait object

D Runtime error: method not found

💡 Hint

Look at the order of elements in the vector and how trait objects work.

The vector animals contains references to Cat then Dog. The loop calls make_sound for each, printing "Meow" then "Woof".