Além do conceito de método, a Rust utiliza outro conceito vindo de linguagens orientadas a objeto: interface.

Em Rust, interface é conhecida como Trait. O objetivo da trait é definir um contrato por meio de métodos abstratos de forma que sejam implementados em tipos de dados.

Algumas características:

1. Possui apenas métodos abstratos
2. Não podem ser usada como tipo na declaração de variáveis
3. Por ser implementada por vários tipos
4. Vários tipos podem implementar uma trait
5. Uma trait pode utilizar generics

A declaração de uma Trait em Rust segue a sintaxe básica mostrada abaixo:

Sintaxe:

trait nome_trait {
  fn nome_metodo1(&self);
  //outros métodos
}

Exemplo 1

trait MinhaTrait {
  fn metodo(&self); //protótipo
}

Saída

-

Para a implementação dos métodos definidos, informamos qual Trait desejamos implementar e qual tipo de dado recebera o método. Isso é feito com o uso das palavras reservadas impl e for como mostrado na sintaxe a seguir:

Sintaxe:

impl nome_trait for tipo_destino {
    fn metodo_trait(&self)
}

Onde:

impl: palavra reserva que indica que estamos implementando uma trait
tipo_destino: tipo de dado que implementa a trait. 

Exemplo 2

//definição de tipo
struct MinhaStruct;

//definição de trait
trait MinhaTrait {
	fn metodo(&self);
}
//implementação de trait
impl MinhaTrait for MinhaStruct {
	fn metodo(&self){
      println!("MinhaStruct::metodo");
    }
}
//uso da implementação
fn main(){
    let variavel = MinhaStruct{};
    variavel.metodo();
}

Saída

MinhaStruct::metodo

Assim como funções e métodos, os métodos abstratos de uma Trait podem conter parâmetros e retorno. A sintaxe abaixo mostra o que foi discutido no parágrafo.

Sintaxe

trait nome_trait {
   fn nome_metodo(&self, <parametro>) -> <retorno>;
}

Onde

<parametro>: lista de parâmetros separados por vírgula
<retorno>: lista de tipos de dados para retorno separados por vírgula.

Exemplo 3

//definição de structs
struct MinhaStruct{
//omitido
}
//definição de trait/interface
trait MinhaTrait {
	fn metodo(&self, p:&str) -> i32;
}
//implementação de interface 
impl MinhaTrait for MinhaStruct {
	fn metodo(&self, param: &str) -> i32 {
      println!("{}", param);
      return -1;
    }
}

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

Saída

string
-1

Em relação a parâmetros e retornos, um método abstrato de uma Trait aceita as mesmas regras e possibilidades de métodos concretos.

Um tipo de dado pode implementar uma ou mais traits. Os métodos pertencentes às traits não podem ser homônimos pois Rust não tem suporte a sobrecarga(19/08/2026). Abaixo uma sintaxe básica:

Sintaxe:

impl nome_trait1 for tipo_dado {
    fn metodo_trait1(&self, <parametros>) -> <retornos> {
    //corpo
    }
}

impl nome_trait2 for tipo_dado {
    fn metodo_trait2(&self, <parametros>) -> <retornos> {
    //corpo
    }
}

Exemplo 5

//definição de structs
struct MinhaStruct{
//omitido
}
//definição de trait/interface
trait MinhaTrait1 {
	fn metodo1(&self, p:&str) -> i32;
}

trait MinhaTrait2 {
	fn metodo2(&self, p:&str) -> i32;
}

//implementação de interface 
impl MinhaTrait1 for MinhaStruct {
	fn metodo1(&self, param: &str) -> i32 {
      println!("{}", param);
      return -1;
    }
}

impl MinhaTrait2 for MinhaStruct {
	fn metodo2(&self, param: &str) -> i32 {
      println!("{}", param);
      return -1;
    }
}

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

Saída

string
-1
string
-1

1. 17/08/2026 - versão inicial: declaração, implementar método, parâmetro e retorno, múltiplas traits