Generics with traits in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of generic function with trait bound

What is the output of this Rust program?

Rust

use std::fmt::Display;

fn print_value<T: Display>(value: T) {
    println!("Value: {}", value);
}

fn main() {
    print_value(42);
    print_value("hello");
}

A Value: 42\nValue: hello

B Value: 42\nValue: \"hello\"

C Compilation error: trait bound not satisfied

D Value: 42\nValue: hello\nValue: 42

💡 Hint

Look at the trait bound Display and how it formats values.

The function print_value accepts any type T that implements the Display trait. Both i32 and &str implement Display, so the function prints their values directly without quotes.

🧠 Conceptual

intermediate

Trait bounds in generic structs

Which statement about the following Rust code is true?

struct Container {
    value: T,
}

impl Container {
    fn duplicate(&self) -> (T, T) {
        (self.value.clone(), self.value.clone())
    }
}

A The duplicate() method will fail to compile for all types.

B The struct can hold any type, but duplicate() requires Clone.

C The struct requires Copy trait, not Clone.

D The struct can only hold types that implement the Clone trait.

💡 Hint

Look at the trait bound on the struct definition.

The trait bound T: Clone on the struct means Container can only be created with types that implement Clone. This ensures duplicate() can call clone() safely.

🔧 Debug

advanced

Fix the trait bound error

What error does this Rust code produce?

fn compare(a: T, b: T) -> bool {
    a == b
}

fn main() {
    println!("{}", compare(5, 5));
}

A error: function main must return ()

B error: missing semicolon after println!

C error: binary operation `==` cannot be applied to type `T`

D No error, prints true

💡 Hint

Think about what traits are needed to use == operator.

The generic type T must implement the PartialEq trait to use the == operator. Without this bound, the compiler errors.

❓ Predict Output

advanced

Output of generic trait implementation

What is the output of this Rust program?

Rust

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

struct NewsArticle {
    headline: String,
    location: String,
}

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

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

fn main() {
    let article = NewsArticle {
        headline: String::from("Rust 1.60 Released"),
        location: String::from("Internet"),
    };
    notify(article);
}

A Breaking news: Rust 1.60 Released, Internet

B Breaking news: Rust 1.60 Released - Internet

C Compilation error: missing trait implementation

D Breaking news: NewsArticle

💡 Hint

Look at the summarize method implementation and the notify function.

The Summary trait is implemented for NewsArticle. The notify function calls summarize, which returns the formatted headline and location.

🧠 Conceptual

expert

Trait object vs generic parameter

Which statement correctly explains the difference between using a trait object &dyn Trait and a generic parameter T: Trait in Rust?

A <p><code>&dyn Trait</code> uses dynamic dispatch and allows different types at runtime; <code>T: Trait</code> uses static dispatch and requires a single type at compile time.</p>

B <p><code>&dyn Trait</code> requires the type to implement <code>Copy</code>; <code>T: Trait</code> does not.</p>

C <p><code>T: Trait</code> uses dynamic dispatch; <code>&dyn Trait</code> uses static dispatch.</p>

D <p>Both are identical in performance and usage.</p>

💡 Hint

Think about when Rust decides which method to call: compile time or runtime.

Trait objects like &dyn Trait use dynamic dispatch, meaning the exact method to call is decided at runtime. Generic parameters with trait bounds use static dispatch, where the compiler generates code for each concrete type.