Defining 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 program?

Rust

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

struct Person;

impl Greet for Person {}

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

A Hello from the trait!

B Error: method greet not implemented

C Hello from the struct!

D Compilation error due to missing impl

💡 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 the 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 Speaking from trait

C Compilation error: method speak missing

D Runtime error

💡 Hint

Check if the trait method is overridden in the implementation.

The Dog struct implements Speak and overrides the speak method. So calling d.speak() prints "Woof!".

🔧 Debug

advanced

Identify the error in trait implementation

What error does this Rust code produce?

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 calc = Calculator;
    println!("{}", calc.calculate(10));
}

A Runtime panic due to missing return

B Error: missing semicolon in impl

C Compiles and prints 42

D Error: method `calculate` has wrong signature in impl

💡 Hint

Compare the trait method signature with the implementation.

The trait method calculate expects a parameter x: i32 and returns i32. The implementation must match this signature. The original code missed the parameter and return type, causing a signature mismatch error. The fixed code compiles and prints 42.

❓ Predict Output

advanced

Trait object method call behavior

Given this Rust code, what is the output?

Rust

trait Animal {
    fn sound(&self);
}

struct Cat;

impl Animal for Cat {
    fn sound(&self) {
        println!("Meow");
    }
}

fn make_sound(animal: &dyn Animal) {
    animal.sound();
}

fn main() {
    let c = Cat;
    make_sound(&c);
}

A Runtime error: trait object not implemented

B Compilation error: cannot use trait object

C No output

D Meow

💡 Hint

Consider how trait objects work with dynamic dispatch.

The function make_sound takes a reference to a trait object &dyn Animal. The call animal.sound() uses dynamic dispatch and calls Cat's implementation, printing "Meow".

📝 Syntax

expert

Which option correctly defines a trait with an associated type?

Which of the following Rust trait definitions is syntactically correct?

A

trait Iterator {
    fn next(&mut self) -> Option<Self::Item>;
    type Item = i32;
}

B

trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

C

trait Iterator {
    fn next(&mut self) -> Option<Self::Item>;
    type Item;
}

D

trait Iterator {
    type Item = i32;
    fn next(&mut self) -> Option<Item>;
}

💡 Hint

Check the correct order and syntax for associated types in traits.

Option B is the only syntactically correct definition. In Rust traits, an associated type must be declared before it can be referenced (as `Self::Item`) in method signatures. Options A and C reference `Self::Item` before declaring `type Item`, causing a compilation error (`associated type not found for `Self``). Option B declares the type first but uses unqualified `Item` in the method signature, which cannot resolve to `Self::Item`.

Practice

1. What is the main purpose of defining a trait in Rust?

easy

A. To allocate memory on the heap

B. To specify shared behavior that multiple types can implement

C. To create a new data type with fields

D. To define a function that runs automatically

Solution

1. Step 1: Understand what a trait represents

   A trait in Rust defines a set of methods that types can implement to share behavior.

2. Step 2: Differentiate traits from other Rust features

   Traits are not data types or memory allocators; they describe behavior, unlike structs which hold data.

3. Final Answer:

   To specify shared behavior that multiple types can implement -> Option B

4. Quick Check:

   Traits = shared behavior [OK]

Hint: Traits describe what types can do, not what they hold [OK]

Common Mistakes:

• Confusing traits with structs
• Thinking traits allocate memory
• Believing traits run code automatically

2. Which of the following is the correct syntax to define a trait named Speak with a method say_hello that returns a String?

easy

A. trait Speak { fn say_hello() { String::new() } }

B. trait Speak { fn say_hello() -> String {} }

C. trait Speak { fn say_hello() -> String; }

D. trait Speak { fn say_hello() -> String; {} }

Solution

1. Step 1: Recall trait method syntax

   Trait methods declare signatures with semicolon if no default implementation is given.

2. Step 2: Check each option's syntax

   trait Speak { fn say_hello() -> String; } correctly declares the method signature ending with a semicolon. Options A and C incorrectly provide a body without default implementation syntax. trait Speak { fn say_hello() -> String; {} } has an invalid extra curly brace.

3. Final Answer:

   trait Speak { fn say_hello() -> String; } -> Option C

4. Quick Check:

   Trait method signature ends with semicolon [OK]

Hint: Trait methods without body end with semicolon [OK]

Common Mistakes:

• Adding empty braces instead of semicolon
• Providing method body without default implementation
• Syntax errors with extra braces

3. What will be the output of this Rust code?

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

struct Person {
    name: String,
}

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

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

medium

A. Hello, Alice!

B. Hello, !

C. Compilation error

D. Runtime panic

Solution

1. Step 1: Understand trait implementation

   The trait Greet is implemented for Person, defining greet to return "Hello, {name}!".

2. Step 2: Trace the main function output

   A Person named "Alice" is created, and p.greet() returns "Hello, Alice!" which is printed.

3. Final Answer:

   Hello, Alice! -> Option A

4. Quick Check:

   Trait method returns greeting string [OK]

Hint: Trait method returns formatted string using struct field [OK]

Common Mistakes:

• Forgetting to implement the trait
• Using wrong field name
• Expecting compilation error due to trait

4. Identify the error in this trait implementation code:

trait Describe {
    fn describe(&self) -> String;
}

struct Book {
    title: String,
}

impl Describe for Book {
    fn describe() -> String {
        format!("Book: {}", self.title)
    }
}

medium

A. Missing &self parameter in method implementation

B. Trait method should not return String

C. Struct Book is missing a field

D. Trait Describe is not defined correctly

Solution

1. Step 1: Compare trait method and implementation signatures

   The trait method describe requires &self parameter, but the implementation omits it.

2. Step 2: Understand consequences of missing &self

   Omitting &self causes a mismatch and compilation error because method signatures must match exactly.

3. Final Answer:

   Missing &self parameter in method implementation -> Option A

4. Quick Check:

   Method signatures must match trait exactly [OK]

Hint: Check method parameters match trait exactly [OK]

Common Mistakes:

• Omitting &self in impl method
• Changing return type
• Misunderstanding trait definition

5. Given the trait and structs below, which implementation correctly allows both Cat and Dog to use the Animal trait's sound method?

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

struct Cat;
struct Dog;

// Which impl block is correct?

hard

A. impl Animal for Cat { fn sound(&self) { println!("Meow"); } }
impl Animal for Dog { fn sound(&self) { println!("Woof"); } }

B. impl Animal for Cat { fn sound() -> &'static str { "Meow" } }
impl Animal for Dog { fn sound() -> &'static str { "Woof" } }

C. impl Animal for Cat { fn sound(&self) -> String { String::from("Meow") } }
impl Animal for Dog { fn sound(&self) -> String { String::from("Woof") } }

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

Solution

1. Step 1: Check trait method signature

   The trait Animal requires fn sound(&self) -> &'static str.

2. Step 2: Verify each impl matches signature

   impl Animal for Cat { fn sound(&self) -> &'static str { "Meow" } } impl Animal for Dog { fn sound(&self) -> &'static str { "Woof" } } matches exactly: method takes &self and returns &'static str. impl Animal for Cat { fn sound() -> &'static str { "Meow" } } impl Animal for Dog { fn sound() -> &'static str { "Woof" } } misses &self. impl Animal for Cat { fn sound(&self) -> String { String::from("Meow") } } impl Animal for Dog { fn sound(&self) -> String { String::from("Woof") } } returns String instead of &'static str. impl Animal for Cat { fn sound(&self) { println!("Meow"); } } impl Animal for Dog { fn sound(&self) { println!("Woof"); } } returns nothing (unit type), mismatching return type.

3. Final Answer:

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

4. Quick Check:

   Impl method signature must match trait exactly [OK]

Hint: Match method signature exactly, including &self and return type [OK]

Common Mistakes:

• Omitting &self parameter
• Returning wrong type
• Using println! instead of returning value