Why traits are used in Rust - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a trait named Printable.

Rust

trait Printable {
    fn [1](&self);
}

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

Aprint

Bdisplay

Coutput

Dshow

Attempts:

3 left

💡 Hint

Common Mistakes

Using method names that are not conventional for printing.

The trait method is commonly named print to indicate printing behavior.

2fill in blank

medium

Complete the code to implement the Printable trait for struct Book.

Rust

struct Book {
    title: String,
}

impl Printable for Book {
    fn [1](&self) {
        println!("Book: {}", self.title);
    }
}

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

Adisplay

Bprint

Cshow

Doutput

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different method name than the trait defines.

The method name must match the trait definition, which is print.

3fill in blank

hard

Fix the error in the code by completing the trait bound syntax.

Rust

fn print_item<T: [1]>(item: T) {
    item.print();
}

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

APrintable

BDisplay

CDebug

DClone

Attempts:

3 left

💡 Hint

Common Mistakes

Using unrelated traits like Display or Debug.

The function requires the generic type T to implement the Printable trait to call print().

4fill in blank

hard

Fill both blanks to create a trait and implement it for a struct.

Rust

trait [1] {
    fn print(&self);
}

struct Article {
    content: String,
}

impl [2] for Article {
    fn print(&self) {
        println!("Article: {}", self.content);
    }
}

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

APrintable

BDisplayable

DShowable

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for trait and impl.

The trait name and implementation must match exactly, here both are Printable.

5fill in blank

hard

Fill all three blanks to define a trait, implement it, and use it in a function.

Rust

trait [1] {
    fn print(&self);
}

struct Note {
    text: String,
}

impl [2] for Note {
    fn print(&self) {
        println!("Note: {}", self.text);
    }
}

fn show<T: [3]>(item: T) {
    item.print();
}

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

APrintable

DDisplay

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing trait names or using unrelated traits.

All trait references must be consistent and use Printable.

Practice

1. Why are traits used in Rust programming?

easy

A. To define shared behavior that multiple types can implement

B. To store data in a fixed-size array

C. To create global variables accessible everywhere

D. To write code that only works with one specific type

Solution

1. Step 1: Understand the purpose of traits

   Traits allow different types to share common behavior by defining methods they must implement.

2. Step 2: Compare options with trait purpose

   Only To define shared behavior that multiple types can implement correctly describes traits as defining shared behavior for multiple types.

3. Final Answer:

   To define shared behavior that multiple types can implement -> Option A

4. Quick Check:

   Traits = shared behavior [OK]

Hint: Traits define shared behavior for many types [OK]

Common Mistakes:

• Confusing traits with data storage
• Thinking traits create global variables
• Believing traits limit code to one type

2. Which of the following is the correct syntax to declare a trait named Speak in Rust?

easy

A. trait Speak { fn speak(&self); }

B. struct Speak { fn speak(&self); }

C. impl Speak { fn speak(&self); }

D. fn Speak { fn speak(&self); }

Solution

1. Step 1: Recall trait declaration syntax

   Traits are declared using the keyword trait followed by the trait name and method signatures.

2. Step 2: Match options with correct syntax

   trait Speak { fn speak(&self); } uses trait Speak { fn speak(&self); }, which is the correct syntax.

3. Final Answer:

   trait Speak { fn speak(&self); } -> Option A

4. Quick Check:

   Trait declaration starts with 'trait' keyword [OK]

Hint: Traits start with 'trait' keyword, not struct or impl [OK]

Common Mistakes:

• Using struct or impl instead of trait keyword
• Omitting parentheses in method signature
• Writing function keyword instead of trait

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

trait Greet {
    fn greet(&self);
}

struct Person;

impl Greet for Person {
    fn greet(&self) {
        println!("Hello from Person!");
    }
}

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

medium

A. Compilation error: trait not implemented

B. Hello from Person!

C. Runtime error: method not found

D. No output

Solution

1. Step 1: Check trait implementation

   The struct Person implements the trait Greet with method greet that prints a message.

2. Step 2: Analyze main function call

   In main, calling p.greet() invokes the implemented method, printing "Hello from Person!".

3. Final Answer:

   Hello from Person! -> Option B

4. Quick Check:

   Trait method called prints message [OK]

Hint: Implemented trait methods run as expected [OK]

Common Mistakes:

• Assuming missing trait implementation error
• Confusing trait with struct methods
• Expecting no output without println!

4. Identify the error in this Rust code using traits:

trait Fly {
    fn fly(&self);
}

struct Bird;

impl Fly for Bird {
    fn fly(&self) {
        println!("Bird is flying");
    }
}

fn main() {
    let b = Bird;
    b.fly();
    b.sing();
}

medium

A. Cannot create instance of struct Bird

B. Trait Fly is not implemented correctly

C. Missing semicolon after println!

D. Method sing is not defined for Bird

Solution

1. Step 1: Check methods called on Bird

   The code calls b.fly() and b.sing(). The trait Fly defines fly, but no sing method exists.

2. Step 2: Identify error cause

   Calling b.sing() causes a compile error because sing is not defined for Bird.

3. Final Answer:

   Method sing is not defined for Bird -> Option D

4. Quick Check:

   Undefined method call causes error [OK]

Hint: Check if all called methods are defined [OK]

Common Mistakes:

• Thinking trait implementation is incorrect
• Assuming missing semicolon error
• Believing struct cannot be instantiated

5. You want to write a function that accepts any type that can be converted to a string. Which trait should you use to make your function flexible and reusable?

hard

A. Use the Copy trait to copy values

B. Use the Drop trait to clean up resources

C. Use the Display trait to require string conversion

D. Use the Clone trait to duplicate values

Solution

1. Step 1: Identify trait for string conversion

   The Display trait allows types to be formatted as strings, enabling conversion to string output.

2. Step 2: Match function flexibility requirement

   Using Display as a trait bound lets the function accept any type that can be shown as a string, making it reusable.

3. Final Answer:

   Use the Display trait to require string conversion -> Option C

4. Quick Check:

   Display trait = string conversion [OK]

Hint: Display trait enables string formatting for any type [OK]

Common Mistakes:

• Confusing Copy or Clone with string conversion
• Using Drop trait incorrectly
• Not using trait bounds for flexibility