Trait bounds in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a function that accepts any type implementing the Display trait.

Rust

fn print_value<T: [1]>(value: T) {
    println!("{}", value);
}

Drag options to blanks, or click blank then click option'

ADisplay

BClone

CCopy

DDebug

Attempts:

3 left

💡 Hint

Common Mistakes

Using Clone or Copy traits which do not support formatting with {}.

Using Debug trait which requires {:?} formatting instead.

The Display trait allows formatting with {} in println!. The function requires T to implement Display.

2fill in blank

medium

Complete the code to add a trait bound requiring T to implement both Display and Clone.

Rust

fn clone_and_print<T: [1] + Clone>(value: T) {
    let _copy = value.clone();
    println!("{}", value);
}

Drag options to blanks, or click blank then click option'

AClone

BCopy

CDebug

DDisplay

Attempts:

3 left

💡 Hint

Common Mistakes

Using Copy instead of Display for printing.

Omitting Display trait bound.

The function requires T to implement Display for printing and Clone for cloning. The bound T: Display + Clone expresses this.

3fill in blank

hard

Fix the error in the function signature by adding the correct trait bound for T to be printable with {:?}.

Rust

fn debug_print<T: [1]>(value: T) {
    println!("{:?}", value);
}

Drag options to blanks, or click blank then click option'

ADisplay

BDebug

CClone

DCopy

Attempts:

3 left

💡 Hint

Common Mistakes

Using Display trait which requires {} formatting.

Omitting any trait bound causing compile error.

The Debug trait allows formatting with {:?}. To use println!("{:?}", value), T must implement Debug.

4fill in blank

hard

Fill both blanks to define a function that accepts any type T implementing both Debug and PartialEq traits.

Rust

fn compare_and_print<T: [1] + [2]>(a: T, b: T) {
    if a == b {
        println!("Equal: {:?}", a);
    } else {
        println!("Not equal: {:?} and {:?}", a, b);
    }
}

Drag options to blanks, or click blank then click option'

ADebug

BDisplay

CPartialEq

DClone

Attempts:

3 left

💡 Hint

Common Mistakes

Using Display instead of Debug for printing.

Omitting PartialEq causing comparison error.

The function compares two values with ==, so T must implement PartialEq. It also prints with {:?}, so Debug is needed. The bound is T: Debug + PartialEq.

5fill in blank

hard

Fill both blanks to create a function that returns the larger of two values implementing PartialOrd and Debug.

Rust

fn max_value<T: [1] + [2]>(a: T, b: T) -> T {
    if a > b {
        println!("Max is {:?}", a);
        a
    } else {
        println!("Max is {:?}", b);
        b
    }
}

Drag options to blanks, or click blank then click option'

APartialOrd

BCopy

CDebug

DClone

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting PartialOrd causing comparison error.

Using Display instead of Debug for printing.

The function compares two values with >, so PartialOrd is required. It prints with {:?}, so Debug is also required. The bound is T: PartialOrd + Debug.

Practice

1. What does a trait bound like T: Display mean in Rust?

easy

A. The generic type T cannot implement the Display trait.

B. The generic type T must implement the Display trait.

C. The function only accepts the Display type, not generics.

D. The trait Display is optional for T.

Solution

1. Step 1: Understand trait bounds syntax

   In Rust, T: TraitName means the generic type T must implement the trait TraitName.

2. Step 2: Apply to T: Display

   This means T must implement the Display trait to be used where this bound is required.

3. Final Answer:

   The generic type T must implement the Display trait. -> Option B

4. Quick Check:

   Trait bound T: Display means T implements Display [OK]

Hint: Trait bounds require the type to implement the trait [OK]

Common Mistakes:

• Thinking trait bounds exclude the trait
• Confusing trait bounds with type restrictions
• Assuming trait bounds are optional

2. Which of the following is the correct syntax to add a trait bound for a generic type T that must implement the Clone trait in a function?

easy

A. fn example(value: T) {}

B. fn example(value: T) {}

C. fn example(value: T) {}

D. fn example(value: T) {}

Solution

1. Step 1: Recall trait bound syntax

   The correct syntax to add a trait bound is T: TraitName, with a colon and capitalized trait name.

2. Step 2: Check each option

   fn example(value: T) {} uses T: Clone which is correct. fn example(value: T) {} misses the colon. fn example(value: T) {} misuses where without proper syntax. fn example(value: T) {} uses lowercase clone, which is incorrect.

3. Final Answer:

   fn example<T: Clone>(value: T) {} -> Option D

4. Quick Check:

   Trait bound syntax uses colon and capitalized trait [OK]

Hint: Use colon and capitalized trait for bounds (T: Trait) [OK]

Common Mistakes:

• Omitting colon between type and trait
• Using lowercase trait names
• Incorrect use of where without full syntax

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

use std::fmt::Display;

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

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

medium

A. Value: 42\nValue: hello

B. Value: 42\nValue: "hello"

C. Compilation error because &str does not implement Display

D. Runtime error due to trait bound violation

Solution

1. Step 1: Check trait bounds for types

   Both i32 (42) and &str ("hello") implement the Display trait, so the function accepts both.

2. Step 2: Understand println! macro output

   The macro prints the formatted string with the value. So it prints "Value: 42" and then "Value: hello" on separate lines.

3. Final Answer:

   Value: 42 Value: hello -> Option A

4. Quick Check:

   Both i32 and &str implement Display, so prints both values [OK]

Hint: Check if types implement the trait bound before calling [OK]

Common Mistakes:

• Assuming &str does not implement Display
• Expecting quotes around string output
• Confusing compile and runtime errors

4. Identify the error in this Rust code snippet:

fn print_debug<T>(value: T) {
    println!("{:?}", value);
}

fn main() {
    print_debug(10);
}

medium

A. Missing trait bound T: Debug for value.

B. Incorrect macro usage, should use {} instead of {:?}.

C. Function should return a value, missing return type.

D. No error, code compiles and runs fine.

Solution

1. Step 1: Understand the use of {:?} in println!

   The {:?} format specifier requires the type to implement the Debug trait.

2. Step 2: Check function signature

   The function print_debug has no trait bound on T, so the compiler cannot guarantee T implements Debug.

3. Final Answer:

   Missing trait bound T: Debug for value. -> Option A

4. Quick Check:

   Using {:?} requires T: Debug trait bound [OK]

Hint: Add trait bound when using {:?} formatting [OK]

Common Mistakes:

• Forgetting to add T: Debug bound
• Using {:?} without Debug trait
• Assuming all types implement Debug by default

5. You want to write a generic function that accepts any type T which implements both Clone and Debug traits. Which is the correct way to write the function signature?

hard

A. fn process(value: T) {}

B. fn process(value: T) {}

C. fn process<T>(value: T) where T: Clone + Debug {}

D. }{ )T :eulav(>gubeD + enolC :T

Solution

1. Step 1: Understand trait bounds syntax

   You can specify multiple trait bounds using either T: Trait1 + Trait2 or a where clause like where T: Trait1 + Trait2.

2. Step 2: Analyze options

   fn process(value: T) {} uses T: Clone + Debug which is correct. fn process(value: T) {} incorrectly separates traits with a comma. fn process<T>(value: T) where T: Clone + Debug {} uses a valid where clause. fn process(value: T) {} states "Both A and C are correct" which is not an option here, so only C is correct.

3. Final Answer:

   fn process<T>(value: T) where T: Clone + Debug {} -> Option C

4. Quick Check:

   Multiple trait bounds can be combined with + or where clause [OK]

Hint: Use + or where clause to combine trait bounds [OK]

Common Mistakes:

• Separating trait bounds with commas instead of +
• Confusing where clause syntax
• Using only one trait bound when multiple needed