Implementing traits in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to implement the trait method for the struct.

Rust

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

struct Person {
    name: String,
}

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

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

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

Agreet

Bself

CPerson

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'self' directly instead of 'self.name' inside format!.

Using the struct name 'Person' instead of the field.

The method greet uses self.name to access the name field of the Person struct.

2fill in blank

medium

Complete the code to implement the trait method that returns the area of a shape.

Rust

trait Shape {
    fn area(&self) -> f64;
}

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius [1] self.radius
    }
}

fn main() {
    let c = Circle { radius: 3.0 };
    println!("Area: {}", c.area());
}

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

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using + or - instead of * for multiplication.

Dividing radius by 2 instead of squaring.

The area of a circle is π times the radius squared, so we multiply radius by itself.

3fill in blank

hard

Fix the error in the trait implementation by completing the missing keyword.

Rust

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

struct Book {
    title: String,
}

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

fn main() {
    let b = Book { title: String::from("Rust Book") };
    println!("{}", b.describe());
}

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

Aimpl

Buse

Ctrait

Dstruct

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'trait' or 'struct' instead of 'impl'.

Omitting the keyword entirely.

The keyword 'impl' is used to implement a trait for a struct in Rust.

4fill in blank

hard

Fill both blanks to implement the trait method that returns a formatted string with the struct's fields.

Rust

trait Info {
    fn info(&self) -> String;
}

struct Car {
    make: String,
    year: u32,
}

impl Info for Car {
    fn info(&self) -> String {
        format!("[1] - [2]", self.make, self.year)
    }
}

fn main() {
    let car = Car { make: String::from("Toyota"), year: 2020 };
    println!("{}", car.info());
}

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

A{}

B{:?}

C{year}

D{make}

Attempts:

3 left

💡 Hint

Common Mistakes

Using named placeholders like '{year}' without matching arguments.

Using debug format '{:?}' unnecessarily.

The '{}' placeholder is used to format values in order. Both make and year are formatted with '{}'.

5fill in blank

hard

Fill all three blanks to implement a trait method that returns the full name from first and last names.

Rust

trait FullName {
    fn full_name(&self) -> String;
}

struct User {
    first_name: String,
    last_name: String,
}

impl FullName for User {
    fn full_name(&self) -> String {
        format!("[1] [2]", self.[3], self.last_name)
    }
}

fn main() {
    let user = User { first_name: String::from("John"), last_name: String::from("Doe") };
    println!("{}", user.full_name());
}

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

A{}

Bfirst_name

Clast_name

D{:?}

Attempts:

3 left

💡 Hint

Common Mistakes

Using '{:?}' instead of '{}'.

Accessing the wrong field like self.last_name twice.

The format string uses two '{}' placeholders for first and last names. The first_name field is accessed with self.first_name.

Practice

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

easy

A. To create a new data type

B. To define shared behavior that multiple types can use

C. To allocate memory for variables

D. To write unsafe code blocks

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: Identify the purpose of implementing traits

   Implementing a trait allows different types to have common behavior, enabling polymorphism.

3. Final Answer:

   To define shared behavior that multiple types can use -> Option B

4. Quick Check:

   Traits = shared behavior [OK]

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

Common Mistakes:

• Confusing traits with data types
• Thinking traits allocate memory
• Assuming traits are for unsafe code only

2. Which of the following is the correct syntax to implement a trait named Speak for a struct Dog?

easy

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

B. impl Dog for Speak { fn speak(&self) { println!("Woof!"); } }

C. impl Speak for Dog { fn speak(&self) { println!("Woof!"); } }

D. struct Dog impl Speak { fn speak(&self) { println!("Woof!"); } }

Solution

1. Step 1: Recall the syntax for implementing a trait

   The correct syntax is impl TraitName for TypeName { ... }.

2. Step 2: Match the syntax with the options

   impl Speak for Dog { fn speak(&self) { println!("Woof!"); } } correctly uses impl Speak for Dog and defines the method.

3. Final Answer:

   impl Speak for Dog { fn speak(&self) { println!("Woof!"); } } -> Option C

4. Quick Check:

   impl Trait for Type = correct syntax [OK]

Hint: Use 'impl Trait for Type' to implement traits [OK]

Common Mistakes:

• Swapping trait and type names
• Using trait keyword instead of impl
• Placing impl inside struct

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. Runtime panic

B. Hello, name!

C. Compilation error

D. Hello, Alice!

Solution

1. Step 1: Understand trait implementation

   The trait Greet is implemented for Person with greet returning a formatted string with the person's name.

2. Step 2: Trace the main function output

   Creating Person with name "Alice" and calling p.greet() returns "Hello, Alice!" which is printed.

3. Final Answer:

   Hello, Alice! -> Option D

4. Quick Check:

   Trait method returns greeting with name [OK]

Hint: Trait method returns formatted string with name [OK]

Common Mistakes:

• Assuming trait methods print directly
• Confusing variable names
• Expecting compilation errors without reason

4. Identify the error in this trait implementation and select the fix:

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

struct Book {
    title: String,
}

impl Describe for Book {
    fn describe(&self) {
        println!("{}", self.title);
    }
}

medium

A. Change fn describe(&self) to return String instead of ()

B. Add &mut self to the method signature

C. Remove the trait Describe

D. Change struct Book to enum Book

Solution

1. Step 1: Check trait method signature

   The trait Describe requires describe to return a String.

2. Step 2: Compare implementation signature

   The implementation returns nothing (()) because it only prints, causing a mismatch.

3. Step 3: Fix the method to return a String

   Change the method to return self.title.clone() or a formatted string.

4. Final Answer:

   Change fn describe(&self) to return String instead of () -> Option A

5. Quick Check:

   Trait method return type must match [OK]

Hint: Match trait method return types exactly [OK]

Common Mistakes:

• Ignoring return type mismatch
• Adding unnecessary mutability
• Changing struct type instead of method

5. You want to implement a trait Summary for two structs NewsArticle and Tweet. Both should have a summarize method returning a short string. How can you write a generic function notify that accepts any type implementing Summary and prints its summary?

Choose the correct function signature and body.

hard

A. fn notify(item: T) { println!("{}", item.summarize()); }

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

C. fn notify(item: Summary) { println!("{}", item.summarize()); }

D. fn notify(item: impl Summary) { println!("{}", item.summarize()); }

Solution

1. Step 1: Understand trait bounds in generics

   To accept any type implementing Summary, use a generic type with a trait bound: T: Summary.

2. Step 2: Analyze options for correct syntax

   fn notify(item: T) { println!("{}", item.summarize()); } uses generic syntax with trait bound correctly. fn notify(item: impl Summary) { println!("{}", item.summarize()); } uses impl Summary which is valid but less flexible for complex cases. fn notify<T>(item: T) { println!("{}", item.summarize()); } lacks trait bound, causing error. fn notify(item: Summary) { println!("{}", item.summarize()); } tries to use trait as a type, which is invalid.

3. Final Answer:

   fn notify(item: T) { println!("{}", item.summarize()); } -> Option A

4. Quick Check:

   Generic with trait bound = correct [OK]

Hint: Use generic with trait bound: fn f(x: T) [OK]

Common Mistakes:

• Using trait as a type directly
• Omitting trait bounds in generics
• Confusing impl Trait and generic syntax