Métodos e blocos impl

No Rust, os métodos são semelhantes às funções, mas são definidos no contexto de uma struct (ou enum ou trait), e seu primeiro parâmetro é sempre self, que representa a instância da struct na qual o método está sendo chamado.

Definindo métodos com impl

Para definir métodos em uma estrutura, usamos um bloco impl (implementação) com o nome da estrutura:

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // This is an instance method. It takes &self for reading.
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect = Rectangle { width: 30, height: 50 };

    // Call the method using dot notation
    println!("The area is: {}", rect.area());
}

Funções associadas (estáticas)

Funções definidas em um bloco impl que não aceitam self como seu primeiro parâmetro são chamadas de funções associadas (equivalente a métodos estáticos em outras linguagens).

Eles são frequentemente usados ​​como construtores para retornar novas instâncias da estrutura. Para chamá-los, use a sintaxe de dois pontos duplos :::

impl Rectangle {
    // Associated function
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

fn main() {
    // Call the associated function
    let sq = Rectangle::square(10);
}

Métodos que modificam o estado: &mut self

Se um método precisar modificar os campos da struct, ele deverá declarar seu primeiro parâmetro como &mut self. A própria instância na qual o método é chamado deve ser declarada como mutável (let mut):

impl Rectangle {
    fn double_size(&mut self) {
        self.width *= 2;
        self.height *= 2;
    }
}

Experimente você mesmo