Default method implementations in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of default method call in trait

What is the output of this Rust code?

Rust

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

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 default method!

D No output

💡 Hint

Check if the trait method has a default implementation and if the struct implements the trait without overriding the method.

The trait Greet provides a default implementation for greet. The struct Person implements Greet but does not override greet. So calling p.greet() uses the default method and prints the message.

❓ Predict Output

intermediate

Overriding default method in trait implementation

What will this Rust program print?

Rust

trait Animal {
    fn sound(&self) {
        println!("Some generic sound");
    }
}

struct Dog;

impl Animal for Dog {
    fn sound(&self) {
        println!("Bark");
    }
}

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

A Bark

B Some generic sound

C Compilation error: method already defined

D Runtime error: method not found

💡 Hint

Look if the trait method is overridden in the implementation.

The Dog struct overrides the default sound method from Animal. So calling d.sound() prints "Bark".

🔧 Debug

advanced

Why does this code fail to compile?

Consider this Rust code. Why does it fail to compile?

Rust

trait Calculator {
    fn calculate(&self) -> i32;
    fn double(&self) -> i32 {
        self.calculate() * 2
    }
}

struct MyCalc;

impl Calculator for MyCalc {}

fn main() {
    let c = MyCalc;
    println!("{}", c.double());
}

A Error because default method <code>double</code> cannot call <code>calculate</code>

B Error because <code>calculate</code> is not implemented in <code>MyCalc</code>

C Error because <code>double</code> must be marked as <code>default</code>

D No error, prints 0

💡 Hint

Check if all required trait methods are implemented.

The trait Calculator requires calculate to be implemented. MyCalc does not implement it, so compilation fails. The default method double calls calculate, but that does not provide an implementation.

🧠 Conceptual

advanced

Purpose of default method implementations in traits

What is the main purpose of providing default method implementations in Rust traits?

A To force all implementors to override the method

B To make the trait methods private

C To prevent the trait from being implemented by structs

D To allow trait methods to have a common behavior that can be used or overridden by implementors

💡 Hint

Think about code reuse and flexibility in trait design.

Default method implementations let traits provide common behavior that implementors can use directly or override with their own version. This promotes code reuse and flexibility.

❓ Predict Output

expert

Output of trait object calling default and overridden methods

What is the output of this Rust program?

Rust

trait Speaker {
    fn speak(&self) {
        println!("Default speak");
    }
}

struct Cat;

impl Speaker for Cat {
    fn speak(&self) {
        println!("Meow");
    }
}

struct Robot;

impl Speaker for Robot {}

fn main() {
    let animals: Vec<&dyn Speaker> = vec![&Cat, &Robot];
    for animal in animals {
        animal.speak();
    }
}

A Meow\nDefault speak

B Default speak\nMeow

C Meow\nMeow

D Default speak\nDefault speak

💡 Hint

Check which structs override the speak method and which use the default.

Cat overrides speak to print "Meow". Robot uses the default speak method which prints "Default speak". The vector holds trait objects, so calling speak calls the correct method for each.