polymorphic_enum

Example:

Input:

```rust polymorphicenum!( trait Move { fn execute(&self); fn validfor_state(&self, state: u8) -> bool; }

#[derive(Debug, Clone)]
enum Moves {
    Attack { enemy_id: u32 },
    Defend,
}

); ```

Will expand to:

```rust trait Move { fn execute(&self); fn validforstate(&self, state: u8) -> bool; }

[derive(Debug, Clone)]

struct Attack{ enemy_id: u32 }

[derive(Debug, Clone)]

struct Defend;

[derive(Debug, Clone)]

enum Moves { Attack(Attack), Defend(Defend) }

impl Move for Moves { fn execute(&self) { match self { Moves::Attack(inner) => inner.execute(), Moves::Defend(inner) => inner.execute(), } }

fn valid_for_state(&self, state: u8) -> bool {
    match self {
        Moves::Attack(inner) => inner.valid_for_state(state),
        Moves::Defend(inner) => inner.valid_for_state(state),
    }
}

}

impl From for Moves { fn from(attack: Attack) -> Self { Moves::Attack(attack) } } impl From for Moves { fn from(defend: Defend) -> Self { Moves::Defend(defend) } } impl Into for Moves { fn into(self) -> Attack { match self { Moves::Attack(attack) => attack, _ => panic!("Tried to convert a Moves into a Attack but the enum variant was not Attack"), } } } impl Into for Moves { fn into(self) -> Defend { match self { Moves::Defend(defend) => defend, _ => panic!("Tried to convert a Moves into a Defend but the enum variant was not Defend"), } } } ```

You are now expected to implement the trait for each of the generated structs like so: ```rust impl Move for Attack { fn execute(&self) { println!("Attack!"); }

fn valid_for_state(&self, state: u8) -> bool {
    state == 0
}

}

impl Move for Defend { fn execute(&self) { println!("Defend!"); }

fn valid_for_state(&self, state: u8) -> bool {
    state == 1
}

} ```

Then we can do something like this: ```rust fn testmoves() { // Create a list of Moves let moves: Vec = vec![Attack { enemyid: 1 }.into(), Defend.into()];

for m in moves {
    m.execute(); // Prints "Attack!" and "Defend!"
}

} ```