Trait objects overview in Rust - Step-by-Step Execution

Concept Flow - Trait objects overview

Define Trait

↓

Implement Trait for Types

↓

Create Trait Object (Box<dyn Trait>)

↓

Use Trait Object via Trait Methods

↓

Dynamic Dispatch at Runtime

↓

Program Uses Different Types Uniformly

This flow shows how Rust uses trait objects to allow different types to be handled through a common interface with dynamic dispatch.

Execution Sample

Rust

trait Draw {
    fn draw(&self);
}

struct Circle;
impl Draw for Circle {
    fn draw(&self) { println!("Drawing Circle"); }
}

fn main() {
    let shape: Box<dyn Draw> = Box::new(Circle);
    shape.draw();
}

This code defines a trait, implements it for a type, creates a trait object, and calls a method via dynamic dispatch.

Execution Table

Step	Action	Code Line	State/Value	Output
1	Define trait Draw with method draw	trait Draw { fn draw(&self); }	Trait Draw defined
2	Define struct Circle	struct Circle;	Type Circle defined
3	Implement Draw for Circle	impl Draw for Circle { fn draw(&self) { ... } }	Circle implements Draw
4	Create trait object shape as Box<dyn Draw>	let shape: Box<dyn Draw> = Box::new(Circle);	shape holds Circle as trait object
5	Call draw() on shape (dynamic dispatch)	shape.draw();	Calls Circle's draw method via trait object	Drawing Circle
6	End of execution

💡 Program ends after calling draw() on the trait object.

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
shape	uninitialized	Box containing Circle as dyn Draw	Same (used to call draw)	Same

Key Moments - 3 Insights

Why do we use Box<dyn Draw> instead of just Circle?

Box<dyn Draw> allows storing different types that implement Draw behind a pointer, enabling dynamic dispatch as shown in step 4 and 5 of the execution_table.

How does Rust know which draw() method to call at runtime?

Rust uses dynamic dispatch through the trait object (step 5), which stores a pointer to the actual method implementation for the concrete type.

Can we call draw() directly on Circle without a trait object?

Yes, but then we lose the ability to treat different types uniformly. Trait objects enable calling draw() on any type implementing Draw via the same interface.

Visual Quiz - 3 Questions

Look at the execution_table, what does the variable 'shape' hold after step 4?

A A Circle value directly

B A Box containing Circle as a trait object

C An uninitialized variable

D A reference to the Draw trait

💡 Hint

Check the 'State/Value' column in row for step 4 in execution_table.

At which step does dynamic dispatch happen according to the execution_table?

A Step 3

B Step 4

C Step 5

D Step 2

💡 Hint

Look for the step where draw() is called on the trait object.

If we replaced Box<dyn Draw> with just Circle, what would change in the variable_tracker?

A shape would hold a Circle value directly, no trait object

B shape would still hold a trait object

C shape would be uninitialized

D shape would hold a reference to Draw trait

💡 Hint

Refer to variable_tracker and think about what Box means.

Concept Snapshot

Trait objects let Rust handle different types through a common interface.
Use Box<dyn Trait> to create a trait object.
Calls on trait objects use dynamic dispatch at runtime.
This enables polymorphism without generics.
Trait objects store a pointer to data and method table.
Useful for heterogeneous collections or uniform APIs.

Full Transcript

This visual trace shows how Rust uses trait objects to enable dynamic dispatch. First, a trait Draw is defined with a method draw. Then, a struct Circle is defined and implements Draw. Next, a trait object shape is created as Box<dyn Draw> holding a Circle. When shape.draw() is called, Rust dynamically dispatches to Circle's draw method. The variable tracker shows shape holds the trait object after creation and remains the same after calling draw. Key moments clarify why Box<dyn Draw> is used and how dynamic dispatch works. The quiz tests understanding of trait objects, dynamic dispatch step, and variable state changes. The snapshot summarizes trait objects as a way to use polymorphism in Rust by storing different types behind a common interface pointer.

Practice

1. What is the main purpose of using trait objects in Rust?

easy

A. To allow different types to be used through a common interface at runtime

B. To improve compile-time performance by avoiding dynamic dispatch

C. To create new data types that do not implement any traits

D. To statically bind methods to specific types only

Solution

1. Step 1: Understand trait objects concept

   Trait objects let you use different types that implement the same trait through a common interface.

2. Step 2: Identify dynamic dispatch role

   Trait objects enable dynamic dispatch, meaning method calls are decided at runtime, allowing flexibility.

3. Final Answer:

   To allow different types to be used through a common interface at runtime -> Option A

4. Quick Check:

   Trait objects = common interface + runtime dispatch [OK]

Hint: Trait objects enable runtime method calls on different types [OK]

Common Mistakes:

• Confusing trait objects with static dispatch
• Thinking trait objects create new unrelated types
• Believing trait objects improve compile-time speed

2. Which of the following is the correct syntax to create a trait object reference for a trait named Animal?

easy

A. let a: &Animal = &dog;

B. let a: Animal = &dog;

C. let a: dyn Animal = dog;

D. let a: &dyn Animal = &dog;

Solution

1. Step 1: Recall trait object syntax

   Trait objects require the dyn keyword before the trait name when used as a reference or pointer.

2. Step 2: Check each option

   let a: &dyn Animal = &dog; uses &dyn Animal, which is the correct syntax for a trait object reference.

3. Final Answer:

   let a: &dyn Animal = &dog; -> Option D

4. Quick Check:

   Trait object syntax = &dyn Trait [OK]

Hint: Use &dyn Trait for trait object references [OK]

Common Mistakes:

• Omitting the dyn keyword
• Trying to use trait name without reference
• Assigning trait object without pointer or reference

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

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

struct Dog;
impl Speak for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}

struct Cat;
impl Speak for Cat {
    fn speak(&self) -> String {
        "Meow".to_string()
    }
}

fn animal_speak(animal: &dyn Speak) {
    println!("{}", animal.speak());
}

fn main() {
    let dog = Dog;
    let cat = Cat;
    animal_speak(&dog);
    animal_speak(&cat);
}

medium

A. Woof\nMeow

B. Dog\nCat

C. Woof\nWoof

D. Compilation error due to trait object usage

Solution

1. Step 1: Understand trait implementations

   Dog and Cat both implement the Speak trait with their own speak() returning "Woof" and "Meow" respectively.

2. Step 2: Analyze function calls with trait objects

   animal_speak takes a reference to a dyn Speak trait object and calls speak(), which uses dynamic dispatch to call the correct method.

3. Final Answer:

   Woof\nMeow -> Option A

4. Quick Check:

   Dynamic dispatch calls correct speak() = Woof then Meow [OK]

Hint: Trait objects call correct method at runtime [OK]

Common Mistakes:

• Expecting static dispatch output
• Confusing struct names with method output
• Thinking code causes compilation error

4. Identify the error in the following Rust code using trait objects:

trait Draw {
    fn draw(&self);
}

struct Circle;
impl Draw for Circle {
    fn draw(&self) {
        println!("Drawing Circle");
    }
}

fn main() {
    let c = Circle;
    let obj: Box<Draw> = Box::new(c);
    obj.draw();
}

medium

A. Circle does not implement Draw trait

B. Missing dyn keyword in Box type declaration

C. Cannot call draw() on Box pointer

D. Box::new() requires a reference, not value

Solution

1. Step 1: Check trait object syntax in Box

   Trait objects require the dyn keyword when used as a pointer type like Box.

2. Step 2: Identify missing dyn keyword

   The code uses Box<Draw> instead of Box, causing a syntax error.

3. Final Answer:

   Missing dyn keyword in Box type declaration -> Option B

4. Quick Check:

   Box trait object needs dyn keyword [OK]

Hint: Always use dyn with trait objects in pointers like Box [OK]

Common Mistakes:

• Omitting dyn keyword in trait object types
• Assuming trait implementation is missing
• Thinking Box cannot call trait methods

5. You want to store different shapes (Circle, Square) in a single vector and call their area() method at runtime. Which approach correctly uses trait objects to achieve this?

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

struct Circle { radius: f64 }
struct Square { side: f64 }

impl Shape for Circle {
    fn area(&self) -> f64 { 3.14 * self.radius * self.radius }
}

impl Shape for Square {
    fn area(&self) -> f64 { self.side * self.side }
}

fn main() {
    // Fill in the blank
    let shapes: Vec> = vec![
        Box::new(Circle { radius: 2.0 }),
        Box::new(Square { side: 3.0 }),
    ];

    for shape in shapes.iter() {
        println!("Area: {}", shape.area());
    }
}

hard

A. Use Vec<&Shape> with references to shapes without Box

B. Use Vec<Shape> directly without pointers

C. Use Vec> with Box::new for each shape

D. Use Vec without Box or references

Solution

1. Step 1: Understand trait object storage

   Trait objects must be stored behind pointers like Box or references because their size is unknown at compile time.

2. Step 2: Analyze vector type and initialization

   Using Vec> with Box::new() for each shape correctly stores different types implementing Shape.

3. Final Answer:

   Use Vec> with Box::new for each shape -> Option C

4. Quick Check:

   Trait objects need pointers like Box in collections [OK]

Hint: Store trait objects in Box pointers inside collections [OK]

Common Mistakes:

• Trying to store trait objects directly without pointers
• Using Vec<Shape> which is invalid
• Using references without ensuring lifetime