Defining traits in Rust - Step-by-Step Execution

Concept Flow - Defining traits

Start

↓

Define trait with methods

↓

Implement trait for struct

↓

Create struct instance

↓

Call trait methods on instance

↓

Use trait bounds if needed

↓

End

This flow shows how to define a trait, implement it for a struct, create an instance, and call the trait methods.

Execution Sample

Rust

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());
}

Defines a trait Greet with a greet method, implements it for Person struct, then calls greet on a Person instance.

Execution Table

Step	Action	Evaluation	Result
1	Define trait Greet with method greet	Trait Greet created	Trait Greet ready with greet()
2	Define struct Person with field name	Struct Person created	Person struct ready
3	Implement Greet for Person	Method greet implemented	Person now has greet() method
4	Create instance p of Person with name "Alice"	p = Person { name: "Alice" }	Instance p created
5	Call p.greet()	Calls greet method on p	Returns "Hello, Alice!"
6	Print returned string	Prints to console	Output: Hello, Alice!

💡 Program ends after printing greeting

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
p	undefined	Person { name: "Alice" }	Person { name: "Alice" }	Person { name: "Alice" }
greet() return	undefined	undefined	"Hello, Alice!"	"Hello, Alice!"

Key Moments - 2 Insights

Why do we need to implement the trait for the struct?

Because defining a trait only declares the behavior. Implementing it for a struct provides the actual code for the methods, as shown in step 3 of the execution_table.

What does &self mean in the trait method?

&self means the method takes a reference to the instance, so it can access its data without taking ownership. This is why in step 5, p.greet() can be called without moving p.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output printed at step 6?

A "Alice"

B "Hello, Person!"

C "Hello, Alice!"

D No output

💡 Hint

Check the Result column at step 6 in execution_table

At which step is the greet method actually implemented for Person?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the Action column describing implementation in execution_table

If we change the name field in p to "Bob", what changes in variable_tracker after step 4?

A p becomes Person { name: "Bob" }

B p remains Person { name: "Alice" }

C greet() return changes to "Hello, Alice!"

D No changes

💡 Hint

Check the value of p after step 4 in variable_tracker

Concept Snapshot

trait TraitName {
    fn method(&self) -> ReturnType;
}

struct StructName { ... }

impl TraitName for StructName {
    fn method(&self) -> ReturnType {
        // method body
    }
}

Traits define shared behavior.
Structs implement traits to provide method code.
Use trait methods on struct instances.

Full Transcript

This example shows how to define a trait named Greet with a method greet. Then a struct Person is defined with a name field. The trait Greet is implemented for Person by providing the greet method that returns a greeting string including the person's name. In main, an instance p of Person is created with name "Alice". Calling p.greet() runs the implemented method and returns "Hello, Alice!", which is printed. The execution table traces each step from defining the trait and struct, implementing the trait, creating the instance, calling the method, and printing the output. The variable tracker shows how the variable p and the greet method's return value change during execution. Key moments clarify why implementation is needed and the meaning of &self. The quiz questions test understanding of output, implementation step, and variable changes. This visual trace helps beginners see how traits work in Rust step-by-step.