Traits do Rust e interfaces do Go: impl explícito versus satisfação implícita

O que é

Go: a especificação diz que um tipo implementa uma interface quando pertence ao conjunto de tipos da interface, o que, para interfaces só com métodos, significa ter esses métodos; nenhuma declaração liga os dois. Rust: um trait declara métodos obrigatórios e, opcionalmente, métodos com implementação padrão, e um tipo só o adquire por meio de impl Trait for Type. O livro de Rust explica a orphan rule, parte da coerência (coherence): uma implementação só é permitida se o trait ou o tipo for local ao crate atual, o que garante que dois crates não possam fornecer implementações conflitantes. Traits podem ter tipos e constantes associados, servir como restrições (bounds) em generics (fn f<T: Display>(x: T) ou impl Display na posição de argumento ou de retorno) e ser convertidos em trait objects (Box<dyn Display>). O livro descreve os generics como monomorfizados em tempo de compilação (uma cópia do código por tipo concreto, despacho estático) e os trait objects como despacho dinâmico, resolvido em tempo de execução. Os valores de interface em Go sempre usam despacho dinâmico; os generics de Go (desde a 1.18) usam interfaces como restrições.

Por que importa

Ambos respondem à primeira pergunta de quem vem de linguagens dinâmicas: como escrever código para vários tipos sem herança. O impl explícito de Rust faz com que um tipo não possa satisfazer um trait por acidente, e a orphan rule impede que um trait externo seja implementado diretamente para um tipo externo; o padrão newtype (uma struct wrapper com um único campo) é a forma habitual de contornar isso. A implicitude de Go permite definir uma interface depois, no lado do consumidor, para tipos que ele não controla, e é assim que os testes injetam fakes no lugar de clientes de terceiros.

Como aplicar

• Em Go, defina interfaces pequenas no ponto de uso; em Rust, defina os traits onde o comportamento é especificado e, quando necessário, implemente-os para tipos externos por meio de um newtype local.
• Em Rust, prefira generics com bounds para caminhos críticos de desempenho e coleções homogêneas, e dyn Trait quando uma coleção precisa guardar tipos diferentes ou quando o tempo de compilação e o tamanho do binário pesam mais do que o custo do despacho.
• Use métodos padrão e blanket implementations (impl<T: Display> Describe for T) para dar comportamento a muitos tipos de uma só vez; Go não tem equivalente e recorre a embedding e funções auxiliares.
• Derive traits padrão (Debug, Clone, PartialEq) com #[derive]; em Go, implemente String() e Error() manualmente.

Armadilhas

Rust: um trait precisa estar no escopo (use) para que seus métodos possam ser chamados, e o livro observa que Rust tem regras sobre onde o despacho dinâmico pode ser usado, chamadas de dyn compatibility, de modo que nem todo trait pode se tornar um dyn Trait. Go: um tipo com métodos de receptor por ponteiro satisfaz a interface apenas como ponteiro, e um valor de interface que contém um ponteiro nil não é nil.