traits2.rs Function Equivalence

[Savaesthetic]

In the traits2.rs solution, the function signature for append_bar differs between the trait definition and the Vec<String> implementation.

trait AppendBar {
    fn append_bar(self) -> Self;
}

impl AppendBar for Vec<String> {
    fn append_bar(mut self) -> Self {
        //        ^^^ this is important
        self.push(String::from("Bar"));
        self
    }
}

Why does this compile if the function signatures differ?

My understanding is that because the function is not taking a reference, that the mut keyword is stating that self is mutable within the function. This seems to offer an additional level of freedom compared to the trait signature which states that self is NOT mutable.

In this case how can these two function be considered equivalent?

[KaustubhOG]

Great question, this confused me when I first encountered it too.

The mut on a by-value parameter is purely a local implementation detail and has no effect on the function's type signature.

From the caller's perspective, both of these are identical:

fn append_bar(self) -> Self      // caller passes owned value
fn append_bar(mut self) -> Self  // same, mut is invisible to the caller

The type is (Self) -> Self in both cases. A simpler example:

fn foo(x: i32) {}
fn bar(mut x: i32) { x = 42; } // same signature as foo

Both have type fn(i32). Once ownership is transferred into the function, the value belongs entirely to that function. Whether it mutates it internally is nobody else's business.

So mut self is not relaxing any constraint visible to the outside. It is just telling the compiler "I need to mutate this local binding inside the body." The trait and impl signatures match because their types are identical.

[Mr-Documents]

This works because in Rust, mut in a function parameter only affects how the value can be used inside the function, not its type.

Trait definition:
fn append_bar(self) -> Self;
Takes ownership of self (by value) and returns the same type.
The trait does not require the implementation to avoid mutating self; it only specifies the interface.
Implementation:
fn append_bar(mut self) -> Self
mut self allows the method to modify the owned value inside the function.
The type of self is still Self, which matches the trait.
From the compiler’s perspective, the trait contract is fully satisfied.

Adding mut in the implementation is purely for internal mutability; it does not change the method signature.
The trait only requires ownership and a matching return type, not whether the value is mutated internally.

Think of mut self as:

"I own this value and can modify it before returning it."

Whenever a trait method takes self by value, the implementer can declare it mut if they need to change it internally.
This is why mut self is fully compatible with the trait’s signature.