Trait bounds in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of function using trait bounds with multiple traits

What is the output of this Rust program?

Rust

use std::fmt::Display;

fn print_and_return<T: Display + Clone>(item: T) -> T {
    println!("Item: {}", item);
    item.clone()
}

fn main() {
    let x = print_and_return(42);
    println!("Returned: {}", x);
}

A Compilation error due to missing trait bound

B Item: 42\nReturned: 43

C Item: 42\nReturned: 42

D Runtime panic due to clone failure

💡 Hint

Check the trait bounds on the generic type T and what traits i32 implements.

The function requires T to implement Display and Clone. The integer 42 implements both traits, so the function prints the item and returns a clone of it. The output shows the printed item and the returned value.

❓ Predict Output

intermediate

Output of function with trait bound using where clause

What is the output of this Rust code snippet?

Rust

fn describe<T>(item: T) where T: std::fmt::Debug {
    println!("Debug info: {:?}", item);
}

fn main() {
    describe("hello");
}

A Debug info: hello

B Debug info: "hello"

C Compilation error: missing trait bound

D Runtime error: cannot print debug

💡 Hint

Look at how the Debug trait formats strings with {:?}.

The Debug trait formats string slices with quotes, so the output includes quotes around hello.

❓ Predict Output

advanced

Output of generic function with trait bound and method call

What is the output of this Rust program?

Rust

trait Summary {
    fn summarize(&self) -> String;
}

struct NewsArticle {
    headline: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("Breaking news: {}", self.headline)
    }
}

fn notify<T: Summary>(item: T) {
    println!("Notification: {}", item.summarize());
}

fn main() {
    let article = NewsArticle { headline: String::from("Rust 1.70 released") };
    notify(article);
}

A Notification: Breaking news: Rust 1.70 released

B Notification: Rust 1.70 released

C Compilation error: trait method not found

D Runtime error: method call failed

💡 Hint

Check how the Summary trait is implemented and used in notify.

The notify function requires T to implement Summary and calls summarize. The NewsArticle struct implements Summary, so the output is the formatted string from summarize.

❓ Predict Output

advanced

Output of function with multiple trait bounds and generic struct

What is the output of this Rust code?

Rust

use std::fmt::{Display, Debug};

struct Pair<T> {
    x: T,
    y: T,
}

impl<T: Display + Debug> Pair<T> {
    fn compare_and_display(&self) {
        if self.x == self.y {
            println!("Equal: {}", self.x);
        } else {
            println!("Not equal: {:?} and {:?}", self.x, self.y);
        }
    }
}

fn main() {
    let pair = Pair { x: 5, y: 5 };
    pair.compare_and_display();
}

A Compilation error: trait bound missing for PartialEq

B Not equal: 5 and 5

C Equal: 5

D Runtime error: cannot compare values

💡 Hint

Check which traits are required for the == operator.

The == operator requires the PartialEq trait, but Pair's impl only requires Display and Debug, so the code fails to compile due to missing PartialEq bound.

🧠 Conceptual

expert

Which option correctly explains trait bounds in Rust generics?

Which statement best describes the purpose of trait bounds in Rust generic functions or structs?

A Trait bounds are used to convert generic types into concrete types at compile time.

B Trait bounds automatically implement traits for all generic types used in the function or struct.

C Trait bounds restrict generic types to only primitive types like integers and floats.

D Trait bounds specify the required capabilities a generic type must have to use certain methods or operators.

💡 Hint

Think about why Rust needs trait bounds when calling methods on generic types.

Trait bounds tell the compiler what traits a generic type must implement so that the code can safely call methods or use operators defined by those traits.