Métodos são funções associadas a um tipo de dado do usuário que permite realizar ações sobre esse tipo. Esse conceito vem de programação programação orientada a objeto.

Rust possui suporte a declaração de métodos que são associados a tipos de dados declarados como struct. Para tipos primitivos é necessário o uso de Trait.

Sintaxe:

impl tipo_dado 
{
    fn nome_metodo1 (&self){
        //corpo
    }
    fn nome_metodoN (&self){
    //corpo
    }
}

Onde:

impl: palavra reserva que indica que estamos implementando um método
tipo_dado: tipo de dado receptor do método. 
&self: define a referência ao tipo associado. Sempre o primeiro parâmetro e obrigátorio. 

Exemplo 1

struct MinhaStruct {
    //omitido
}

//definição de método
impl MinhaStruct {
    fn to_string(&self){
         println!("to_string");
    }
}

fn main ()
{
  let variavel = MinhaStruct{};
  variavel.to_string();
}

O acesso a campos de um tipo struct é feito via parâmetro self declarado com primeiro parâmetro. Assim, podemos fazer uso da palavra reservada self em conjunto com o operador (.) para acessar esses campos como pode ser visto abaixo:

Sintaxe:

impl tipo_struct {
	fn nome_metodo(&self){
        //corpo
    }
}

Sintaxe:

self.nome_membro [=valor];

Exemplo 2

struct MinhaStruct {
    id:i8
}

//definição de método
impl MinhaStruct {
    fn to_string(&self){
         println!("{}",self.id);
    }
}

fn main ()
{
  let variavel = MinhaStruct{id:1};
  variavel.to_string();
}

Saída

1

A declaração de parâmetros em um métodos é feita da mesma forma vista em Funções. A diferença é que o parâmetro &self sempre deve ser o primeiro parâmetro.

Sintaxe: método

impl tipo_struct {
    fn nome_metodo(&self){
        //corpo
    }
}

Sintaxe: parâmetro

nome_parametro: tipo_dado

Onde

<parametros>: lista de parâmetros separados por vírgula

Exemplo 3

struct MinhaStruct {
//omitido
}

//definição de método
impl MinhaStruct {
    fn to_string(&self) -> i8{
         return 1;
    }
}

fn main ()
{
  let variavel = MinhaStruct{};
  let ret = variavel.to_string();
  println!("{}",ret);
}

Saída

1

O retorno de valores de métodos também é semelhante ao que foi aplicado para retorno de valores em funções aprendidos anteriormente.

Sintaxe

impl tipo_struct {
	fn nome_metodo(&self) -> tipo_retorno {
        return <valor_retorno>;
    }
}

Onde

<valor_retorno>: valor ou expressão para retorno

Exemplo 4

struct MinhaStruct {
//omitido
}

//definição de método
impl MinhaStruct {
    fn to_string(&self) -> i8{
         1 //SEM RETURN
    }
}

fn main ()
{
  let variavel = MinhaStruct{};
  let ret = variavel.to_string();
  println!("{}",ret);
}

O uso do comando return é opcional quando o valor retorno é apenas um valor ou expressão simples contendo os parâmetros do método. Nesse casos, o terminador (;) devo ser omitido.

Sintaxe

impl tipo_struct {
	fn nome_metodo(&self) -> tipo_retorno {
        <valor_retorno>
    }
}

Onde

<valor_retorno>: valor ou expressão para retorno

Exemplo 5

struct MinhaStruct {
//omitido
}

//definição de método
impl MinhaStruct {
    fn metodo1(&self) -> i8{
         1
    }
    
    fn metodo2(&self, p: i8) -> i8{
         p*2
    }
}

fn main ()
{
  let variavel = MinhaStruct{};
  let mut ret = variavel.metodo1();
  println!("{}",ret);
  ret = variavel.metodo2(2);
  println!("{}",ret);
}

Saída

1
4

O que foi estudado em Funções sobre passagem por valor por referência também é válido para ser aplicado a métodos: mut para valor e &mut para referência:

Sintaxe

fn nome_metodo(&self, nome_parametro: &mut i8) //referência
fn nome_metodo(&self, mut param:i8) //valor

Exemplo 6

struct MinhaStruct{
 //omitido
}
//definição de método
impl MinhaStruct 
{
    //passagem por referência usando: &mut
    fn metodo1(&self, _param: &mut i8)
    {
        *_param = 99; //alterando valor de um argumento
    }
    //passagem por valor usando apenas: mut
    fn metodo2(&self, mut _param:i8)
    {
        //alteração não irá refletir
        //no argumento passado na main
        _param = 99; 
    }
}

fn main ()
{
  let variavel = MinhaStruct{};
  let mut variavel2:i8 = -1;
  
  println!("Valor - Antes: {}",variavel2);
  variavel.metodo2(variavel2); //alteração de argumento
  println!("Valor - Depois: {}",variavel2); 
  println!("Ref. - Antes: {}",variavel2);
  variavel.metodo1(&mut variavel2); //alteração de argumento
  println!("Ref. - Depois: {}",variavel2); 
}

Saída

Valor - Antes: -1
Valor - Depois: -1
Ref. - Antes: -1
Ref. - Depois: 99

1. 17/08/2026 - versão inicial: declaração, acessar campos, parâmetro, retorno e valor/referência.