Default method implementations in Rust - Step-by-Step Execution

Concept Flow - Default method implementations

Define Trait with Default Method

↓

Implement Trait for Struct

↓

Use Default Method from Trait

↓

Call Method on Struct Instance

↓

Default Method Runs

↓

Output Result

This flow shows how a trait with a default method is defined, implemented by a struct, and how calling the method uses the default implementation.

Execution Sample

Rust

trait Greet {
    fn say_hello(&self) {
        println!("Hello from default method!");
    }
}

struct Person;

impl Greet for Person {}

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

This Rust code defines a trait with a default method, implements it for a struct without overriding, then calls the default method.

Execution Table

Step	Action	Evaluation	Result
1	Define trait Greet with default method say_hello	Trait created with default method	Trait Greet with say_hello() exists
2	Define struct Person	Struct created	Struct Person exists
3	Implement trait Greet for Person without overriding say_hello	Implementation uses default method	Person implements Greet using default say_hello
4	Create instance p of Person	Instance created	p is Person instance
5	Call p.say_hello()	No override, calls default method	Prints: Hello from default method!
6	Program ends	No more code	Execution stops

💡 Program ends after calling default method once

Variable Tracker

Variable	Start	After Step 4	Final
p	undefined	Person instance	Person instance

Key Moments - 2 Insights

Why does calling say_hello() on Person print the default message?

Because in step 3 (execution_table row 3), Person implements Greet but does not override say_hello, so the default method from the trait is used.

Can we override the default method in the implementation?

Yes, but in this example (step 3), we did not override, so the default runs. Overriding would replace the default method.

Visual Quiz - 3 Questions

Look at the execution table, what is printed when p.say_hello() is called at step 5?

A Hello from default method!

B No output

C Compilation error

D Custom message from Person

💡 Hint

See execution_table row 5 where the default method prints the message.

At which step is the Person instance created?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Check execution_table row 4 where instance p is created.

If we override say_hello in Person's impl, what changes in the execution?

A The default method is still called

B Compilation fails

C The overridden method runs instead

D The method call is ignored

💡 Hint

Refer to key_moments where overriding replaces the default method.

Concept Snapshot

trait TraitName {
    fn method(&self) { // default implementation
        // code
    }
}

struct StructName;

impl TraitName for StructName {
    // can override method or use default
}

// Calling method on StructName instance uses default if not overridden

Full Transcript

This example shows how Rust traits can have default method implementations. We define a trait Greet with a default method say_hello that prints a message. Then we create a struct Person and implement Greet for it without overriding say_hello. When we create an instance of Person and call say_hello, the default method runs and prints the message. This demonstrates how default methods provide reusable behavior that can be used or overridden by implementers.

Practice

1. What is the main purpose of default method implementations in Rust traits?

easy

A. To automatically generate structs from traits

B. To force all types to implement the method themselves

C. To prevent any method from being used outside the trait

D. To provide reusable behavior that types can use or override

Solution

1. Step 1: Understand trait default methods

   Default methods in traits provide a common implementation that types can use without writing their own code.

2. Step 2: Compare with other options

   Options A, B, and C describe behaviors that are not true for default methods in Rust traits.

3. Final Answer:

   To provide reusable behavior that types can use or override -> Option D

4. Quick Check:

   Default methods = reusable behavior [OK]

Hint: Default methods give ready code to reuse or replace [OK]

Common Mistakes:

• Thinking default methods force implementation
• Confusing traits with structs
• Believing default methods hide methods

2. Which of the following is the correct syntax to define a default method in a Rust trait?

easy

A. fn greet() { println!("Hello"); }

B. fn greet();

C. fn greet() -> { println!("Hello"); }

D. fn greet() => println!("Hello");

Solution

1. Step 1: Recall Rust trait method syntax

   Default methods in traits have a body with curly braces, like fn greet() { ... }.

2. Step 2: Check each option

   fn greet() { println!("Hello"); } uses correct syntax with braces. fn greet(); is a method signature without body (no default). Options A and D have invalid syntax.

3. Final Answer:

   fn greet() { println!("Hello"); } -> Option A

4. Quick Check:

   Default method = fn name() { body } [OK]

Hint: Default methods always have braces with code inside [OK]

Common Mistakes:

• Omitting braces for default methods
• Using arrow syntax instead of braces
• Writing only method signatures without body

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

trait Speak {
    fn say(&self) {
        println!("Default speaking");
    }
}

struct Dog;

impl Speak for Dog {}

fn main() {
    let d = Dog;
    d.say();
}

medium

A. Dog says woof

B. Compilation error: method say not implemented

C. Default speaking

D. No output

Solution

1. Step 1: Analyze trait and struct implementation

   The trait Speak has a default method say that prints "Default speaking". Dog implements Speak but does not override say.

2. Step 2: Determine method called

   Since Dog does not override say, calling d.say() uses the default method from the trait.

3. Final Answer:

   Default speaking -> Option C

4. Quick Check:

   Default method runs if not overridden [OK]

Hint: If no override, default method runs [OK]

Common Mistakes:

• Expecting an error for missing method
• Assuming default method is not used
• Confusing struct behavior with trait methods

4. Identify the error in this Rust code using default method implementations:

trait Talk {
    fn talk(&self) {
        println!("Talking");
    }
}

struct Cat;

impl Talk for Cat {
    fn talk(&self);
}

fn main() {
    let c = Cat;
    c.talk();
}

medium

A. Trait Talk must not have default methods

B. Missing method body in impl causes compilation error

C. Struct Cat cannot implement Talk

D. No error, code runs fine

Solution

1. Step 1: Check impl block for talk method

   The impl for Cat declares fn talk(&self); without a body, which is invalid syntax in Rust.

2. Step 2: Understand default method usage

   Since Talk trait has a default talk method, Cat can omit implementing it or provide a full method body. Declaring without body causes error.

3. Final Answer:

   Missing method body in impl causes compilation error -> Option B

4. Quick Check:

   Impl methods need bodies unless default used [OK]

Hint: Impl methods must have bodies or be omitted [OK]

Common Mistakes:

• Declaring method without body in impl
• Thinking default method forces impl
• Ignoring compiler error messages

5. Given this trait and structs, how can you override the default method only for Cat while Dog uses the default?

trait Animal {
    fn sound(&self) {
        println!("Some sound");
    }
}

struct Dog;
struct Cat;

impl Animal for Dog {}
impl Animal for Cat {
    // What goes here?
}

fn main() {
    let dog = Dog;
    dog.sound();
    let cat = Cat;
    cat.sound();
}

hard

A. fn sound(&self) { println!("Meow"); }

B. fn sound(&self);

C. fn sound() { println!("Meow"); }

D. fn sound(&self) -> String { "Meow".to_string() }

Solution

1. Step 1: Understand overriding default methods

   To override a default method, provide a method with the same signature and a body in the impl block.

2. Step 2: Check options for correct override syntax

   fn sound(&self) { println!("Meow"); } correctly defines fn sound(&self) with a body printing "Meow". fn sound(&self); lacks body, causing error. fn sound() { println!("Meow"); } misses &self parameter. fn sound(&self) -> String { "Meow".to_string() } changes return type, incompatible with trait.

3. Final Answer:

   fn sound(&self) { println!("Meow"); } -> Option A

4. Quick Check:

   Override = same signature + method body [OK]

Hint: Override with same signature and method body [OK]

Common Mistakes:

• Omitting &self parameter
• Declaring method without body
• Changing return type in override