10.6 Enums vs. Inheritance in OOP

In many object-oriented languages, inheritance is used to represent a group of related types that share behavior yet differ in certain details.

10.6.1 OOP Approach (Java Example)

abstract class Message {
    abstract void process();
}

class Quit extends Message {
    void process() {
        System.out.println("Quit message");
    }
}

class Move extends Message {
    int x, y;
    Move(int x, int y) { this.x = x; this.y = y; }
    void process() {
        System.out.println("Move to x: " + x + ", y: " + y);
    }
}
  • Subclassing: Each message variant is a subclass.
  • Polymorphism: process is called based on the actual instance type at runtime.

10.6.2 Rust’s Approach with Enums

Rust enums can model similar scenarios without requiring inheritance:

  • Single Type: One enum with multiple variants.
  • Pattern Matching: A single match can handle all variants.
  • No Virtual Dispatch: No dynamic method table is needed for enum variants.
  • Exhaustive Checking: The compiler ensures you handle every variant.

10.6.3 Trait Objects as an Alternative

While enums work well when the set of variants is fixed, Rust also supports trait objects for runtime polymorphism:

trait Message {
    fn process(&self);
}

struct Quit;
impl Message for Quit {
    fn process(&self) {
        println!("Quit message");
    }
}

struct Move {
    x: i32,
    y: i32,
}
impl Message for Move {
    fn process(&self) {
        println!("Move to x: {}, y: {}", self.x, self.y);
    }
}

fn main() {
    let messages: Vec<Box<dyn Message>> = vec![
        Box::new(Quit),
        Box::new(Move { x: 10, y: 20 }),
    ];

    for msg in messages {
        msg.process();
    }
}
  • Dynamic Dispatch: The correct process method is chosen at runtime.
  • Heap Allocation: Each object is stored on the heap via a Box.

We’ll explore trait objects in more detail in Chapter 20 when we discuss Rust’s approach to object-oriented programming.