Traits

TypeScript interfaces are structural — Rust traits are nominal

In TypeScript, interfaces use structural typing: if an object has the right shape (the right properties and methods), it satisfies the interface — no explicit declaration needed.

Rust traits use nominal typing: a type only implements a trait if you explicitly write impl Trait for Type. Matching the shape is not enough. This distinction has important consequences for library design and correctness.

// TypeScript — structural typing
interface Greet {
  name(): string;
  hello(): string;
}

// No explicit declaration — just match the shape
const english = {
  name: () => "world",
  hello() { return `Hello, ${this.name()}!`; }
};

function greetSomething(g: Greet) {
  console.log(g.hello());
}

greetSomething(english); // works — english has the right shape

trait Greet {
    fn name(&self) -> &str;
    // Default method — free implementation, can be overridden
    fn hello(&self) -> String {
        format!("Hello, {}!", self.name())
    }
}

struct English;
struct Thai;

impl Greet for English {
    fn name(&self) -> &str { "world" }
    // Uses the default hello()
}

impl Greet for Thai {
    fn name(&self) -> &str { "โลก" }
    // Override the default
    fn hello(&self) -> String {
        format!("สวัสดี {}!", self.name())
    }
}

fn greet_something(g: &dyn Greet) {
    println!("{}", g.hello());
}

fn main() {
    greet_something(&English);
    greet_something(&Thai);
}

🟦 Traits vs interfaces — key differences

	TypeScript interface	Rust trait
Typing	Structural (duck typing)	Nominal (explicit `impl`)
Default methods	No (use abstract classes)	Yes (`fn method(&self) { ... }`)
Implement for foreign types	Yes — just add the property	No — coherence rule prevents it
Derive / auto-generate	No	Yes — `#[derive(Debug, Clone, ...)]`
Used as generic bound	`function f<T extends Greet>(t: T)`	`fn f<T: Greet>(t: T)`

The coherence (orphan) rule: In Rust, you can only implement a trait for a type if you own either the trait or the type. You cannot implement a third-party trait on a third-party type. This prevents conflicting implementations across crates and makes the type system globally consistent. TypeScript has no such rule.

Deriving common traits

Rust can auto-generate implementations for many common traits using #[derive(...)]. TypeScript has no equivalent — you implement interfaces manually or use class inheritance.

// TypeScript — implement interfaces manually or use classes
interface Printable {
  toString(): string;
}

class Point implements Printable {
  constructor(public x: number, public y: number) {}
  toString(): string {
    return `Point { x: ${this.x}, y: ${this.y} }`;
  }
  clone(): Point {
    return new Point(this.x, this.y);
  }
}

const p = new Point(1, 2);
console.log(p.toString());

// Rust — derive common traits automatically
#[derive(Debug, Clone, PartialEq)]
struct Point {
    x: f64,
    y: f64,
}

fn main() {
    let p1 = Point { x: 1.0, y: 2.0 };
    let p2 = p1.clone();           // Clone derived
    println!("{:?}", p1);          // Debug derived — prints: Point { x: 1.0, y: 2.0 }
    println!("equal: {}", p1 == p2); // PartialEq derived
}

Try it

Open in Rust Playground

trait Greet {
    fn name(&self) -> &str;
    fn hello(&self) -> String {
        format!("Hello, {}!", self.name())
    }
}

struct English;
struct Thai;

impl Greet for English {
    fn name(&self) -> &str { "world" }
}

impl Greet for Thai {
    fn name(&self) -> &str { "โลก" }
    fn hello(&self) -> String {
        format!("สวัสดี {}!", self.name())
    }
}

fn main() {
    let e = English;
    let t = Thai;
    println!("{}", e.hello());
    println!("{}", t.hello());
}