🦀 Self vs self in Rust

If you’re learning Rust, few things feel more confusing at first than the difference between Self and self. They look similar, they sound similar, and they often appear right next to each other. But once you internalize one simple rule, the confusion almost completely disappears.

The Rule of Thumb (Memorize This)

If a function does NOT take self, call it with Self::.
If a function DOES take &self or &mut self, call it with self.

That’s it. Seriously.

Here’s what that looks like in practice:

Self::random_food(...)
Self::new(...)
Self::from_config(...)

These are associated functions. They belong to the type, not to any particular value.

Now compare that with:

self.update();
self.draw();
self.handle_input();

These are methods. They operate on a specific instance of the type.

A Tiny Example That Says Everything

impl Game {
    fn foo() {
        println!("no self");
    }

    fn bar(&self) {
        println!("has self");
    }

    fn test(&self) {
        Self::foo();   // ✅ correct
        self.bar();    // ✅ correct
    }
}

If you try self::foo(), Rust will reject it.
If you try Self::bar(), Rust will reject that too.

And Rust is absolutely right to do so.

Why? Because foo doesn’t need an instance of Game, while bar cannot exist without one. Mixing those two ideas would blur an important line—and Rust refuses to let that happen.

Why Rust Is So Strict (And Why That’s a Good Thing)

Rust forces you to be explicit about what you’re talking about:

• self → a value (this specific instance)
• Self → a type (the struct itself)
• self::, super::, crate:: → modules and scope

This strictness isn’t pedantry—it’s clarity. Once you stop guessing and start asking “is this function about the type or about a value?”, your code becomes easier to read, easier to reason about, and harder to misuse.

Many “mysterious” Rust errors vanish once this clicks. You stop fighting the compiler and start understanding what it’s protecting.

The Big Payoff

When Self vs self finally lands, a huge chunk of Rust suddenly feels predictable. Constructors make sense. Game loops make sense. Trait implementations make sense.