Rust traits versus Go interfaces: explicit impl, implicit satisfaction

What it is

Go: the specification says a type implements an interface when it belongs to the interface's type set, which for method-only interfaces means it has those methods; no declaration links the two. Rust: a trait declares required and optionally default methods, and a type gains it only through impl Trait for Type. The Rust book explains the orphan rule, part of coherence: an implementation is allowed only if the trait or the type is local to the current crate, which guarantees that two crates cannot ship conflicting implementations. Traits can carry associated types and constants, act as bounds on generics (fn f<T: Display>(x: T) or impl Display in argument or return position), and be turned into trait objects (Box<dyn Display>). The book describes generics as monomorphised at compile time (one copy of the code per concrete type, static dispatch) and trait objects as dynamic dispatch resolved at run time. Go interface values are always dynamically dispatched; Go generics (since 1.18) use interfaces as constraints instead.

Why it matters

Both answer the first question dynamic-language programmers ask: how to write code for several types without inheritance. Rust's explicit impl means a type cannot satisfy a trait by accident, and the orphan rule means a foreign trait cannot be implemented for a foreign type directly; the newtype pattern (a one-field wrapper struct) is the usual way around it. Go's implicitness means an interface can be defined after the fact, at the consumer, for types the consumer does not own, which is how tests inject fakes for third-party clients.

How to apply

• In Go, define small interfaces at the point of use; in Rust, define traits where the behaviour is specified and implement them for foreign types via a local newtype when needed.
• In Rust, prefer generics with bounds for hot paths and homogeneous collections, and dyn Trait when a collection must hold different types or when compile time and binary size matter more than dispatch cost.
• Use default methods and blanket implementations (impl<T: Display> Describe for T) to give behaviour to many types at once; Go has no equivalent and relies on embedding and helper functions.
• Derive standard traits (Debug, Clone, PartialEq) with #[derive]; in Go, implement String() and Error() by hand.

Pitfalls

Rust: a trait must be in scope (use) for its methods to be callable, and the book notes that Rust has rules about where dynamic dispatch can be used, called dyn compatibility, so not every trait can become a dyn Trait. Go: a type with pointer-receiver methods satisfies the interface only as a pointer, and an interface value holding a nil pointer is not nil.