[]Keyword self

The receiver of a method, or the current module.

self is used in two situations: referencing the current module and marking the receiver of a method.

In paths, self can be used to refer to the current module, either in a use statement or in a path to access an element:

use std::io::{self, Read};
Run

Is functionally the same as:

use std::io;
use std::io::Read;
Run

Using self to access an element in the current module:

fn foo() {}
fn bar() {
    self::foo()
}
Run

self as the current receiver for a method allows to omit the parameter type most of the time. With the exception of this particularity, self is used much like any other parameter:

struct Foo(i32);

impl Foo {
    // No `self`.
    fn new() -> Self {
        Self(0)
    }

    // Consuming `self`.
    fn consume(self) -> Self {
        Self(self.0 + 1)
    }

    // Borrowing `self`.
    fn borrow(&self) -> &i32 {
        &self.0
    }

    // Borrowing `self` mutably.
    fn borrow_mut(&mut self) -> &mut i32 {
        &mut self.0
    }
}

// This method must be called with a `Type::` prefix.
let foo = Foo::new();
assert_eq!(foo.0, 0);

// Those two calls produces the same result.
let foo = Foo::consume(foo);
assert_eq!(foo.0, 1);
let foo = foo.consume();
assert_eq!(foo.0, 2);

// Borrowing is handled automatically with the second syntax.
let borrow_1 = Foo::borrow(&foo);
let borrow_2 = foo.borrow();
assert_eq!(borrow_1, borrow_2);

// Borrowing mutably is handled automatically too with the second syntax.
let mut foo = Foo::new();
*Foo::borrow_mut(&mut foo) += 1;
assert_eq!(foo.0, 1);
*foo.borrow_mut() += 1;
assert_eq!(foo.0, 2);
Run

Note that this automatic conversion when calling foo.method() is not limited to the examples above. See the Reference for more information.