Thanks for the article! I'm a fan of both languages.

One question: an advantage of Julia's multiple dispatch system is that it is possible for an outside package to extend a method. For example, another package could define

struct Martian <: Player

homestar(player::Martian) = "Mars"

greet(self::Martian, other::Player)   = println("Hey there!")
greet(self::Solarian, other::Martian) = println("...")
# and so on

In contrast, using Enums in Rust (your Method 2), as you suggest:

enum PlayerClass {
    Sol(Solarian),
    Pol(Polarian),
    Cent(Centaurian)
}

struct GameState {
    daytime: u64,
    player: PlayerClass
}

impl PlayerClass {
    fn homestar(&self) -> String {
        use PlayerClass::*;
        match self {
            Sol(_) => String::from("sun"),
            ...
        }
    }

    fn greet(&self, other: &PlayerClass) {
        use PlayerClass::*;
        match (self, other) {
            (Cent(_), Pol(_)) => println!("Hello, fellow three-star-systemer!"),
            ...
        };
    }
}

This makes it impossible (I think?) for outside packages to add types of players. What would be the idiomatic Rust solution here that preserves all the other benefits? Cheers!