Difference Between `self` and `Self` in Rust

By the end of this page, you will understand that self and Self are different concepts in Rust. self usually refers to the current instance inside a method, while Self refers to the current type inside an impl block or trait. You will see where each is used, how their syntax differs, and how they appear in real Rust code.

In Rust, self and Self are related, but they mean different things.

• self refers to the current value or instance of a type.
• Self refers to the type itself.

This distinction matters because Rust makes a clear separation between:

• a value created from a type
• the type definition itself

self means the current instance

You use self in methods when you want to work with the object the method was called on.

For example:

struct User {
    name: String,
}

impl User {
    fn greet(&self) {
        println!("Hello, {}", self.name);
    }
}

Here:

• &self means the method borrows the current User
• self.name accesses a field on that specific instance

Self means the current type

Think of a class blueprint and a built object.

• Self is the blueprint name: the type itself
• self is the actual object in your hands

If you build a Car:

• Self means Car
• self means a specific car, such as your blue car parked outside

So:

• use Self when talking about what kind of thing it is
• use self when talking about the current thing itself

Core syntax

Using self in methods

struct Counter {
    value: i32,
}

impl Counter {
    fn show(&self) {
        println!("{}", self.value);
    }

    fn increment(&mut self) {
        self.value += 1;
    }

    fn consume(self) {
        println!("Final value: {}", self.value);
    }
}

What these mean

• &self borrows the current instance immutably
• &mut self borrows the current instance mutably
• self takes ownership of the current instance

Using Self in return types and constructors

  {
    value: ,
}

  {
     ()   {
         { value:  }
    }
}

Consider this example:

struct Book {
    title: String,
}

impl Book {
    fn new(title: String) -> Self {
        Self { title }
    }

    fn print_title(&self) {
        println!("{}", self.title);
    }
}

fn main() {
    let book = Book::new(String::from("Rust Basics"));
    book.print_title();
}

Step by step:

1. struct Book defines a type named Book.
2. Inside impl Book, Self refers to the type Book.
3. fn new(title: String) -> Self says that new returns a .

You will commonly see self and Self in these situations:

Struct methods

impl Config {
    fn validate(&self) -> bool {
        !self.path.is_empty()
    }
}

Use self because the method checks data on the current instance.

Constructors and factory methods

impl Config {
    fn default() -> Self {
        Self {
            path: String::from("./app.conf"),
        }
    }
}

Use Self because the function returns a new value of the type.

Trait definitions

trait Parseable {
    fn (input: &)  ;
}

In real Rust projects, developers use self and Self in predictable patterns.

Instance methods

Methods that inspect or modify fields usually take one of these forms:

• &self for read-only access
• &mut self for modification
• self when consuming the value

impl Session {
    fn is_expired(&self) -> bool {
        self.expires_at < 1000
    }

    fn refresh(&mut self) {
        self.expires_at += 3600;
    }
}

Constructors and named constructors

impl Session {
    fn new() -> Self {
        Self { expires_at: 0 }
    }
}

1. Thinking self and Self are interchangeable

They are not.

• self is a value
• Self is a type

Broken example:

struct User;

impl User {
    fn make() -> self {
        self
    }
}

This is invalid because self is not a type.

Correct version:

struct User;

impl User {
    fn make() -> Self {
        Self
    }
}

2. Using self outside a method receiver context incorrectly

Broken example:

  {
    name: ,
}

  {
     () {
        (, .name);
    }
}

self receiver forms

• self = the current instance
• Self = the current type

Common patterns

fn show(&self)
fn update(&mut self)
fn consume(self)
fn new() -> Self

Examples

impl User {
    fn new(name: String) -> Self {
        Self { name }
    }

    fn greet(&self) {
        println!("Hi, {}", self.name);
    }
}

Remember

• self.name accesses a field on the current value
• Self { ... } constructs a value of the current type

What does self mean in Rust?

self refers to the current instance of a type inside a method. It lets you read or modify that specific value.

What does Self mean in Rust?

Self refers to the current type inside an impl block or trait. It is often used in return types and constructors.

Is Self the same as the struct name in Rust?

Inside an impl block, yes. For example, inside impl User, Self means User.

Why does Rust use both self and Self?

Because one is for values and the other is for types. Rust keeps those ideas separate to make code clearer and safer.

When should I use Self instead of the type name?

Usually inside impl blocks and traits, especially for constructors and return types. It makes code easier to refactor.

Can I use self in a function that is not a method?

• impl blocks — Self is commonly used inside implementations for a type.
• methods in Rust — self appears as the receiver in instance methods.
• ownership and borrowing — &self, &mut self, and self follow Rust ownership rules.
• traits — Self is important in trait definitions and implementations.
• associated functions — functions like new() often return Self.
• struct syntax — Self { ... } is often used to construct struct instances.