enum Foo {
    A(Box<u8>),
    B(Box<u8>)
}

#[derive(Copy, Clone, Debug)]
enum SwitchMode {
    A,
    B
}

impl Foo {
    fn update(&mut self) -> SwitchMode {
        // run the update
        match self {
            Foo::A(_) => { return SwitchMode::B }
            Foo::B(_) => { return SwitchMode::A }
        }
    }

    fn switch_mode(self, mode: SwitchMode) -> Foo {
        // change the mode
        #[allow(unreachable_patterns)]
        match (self, mode) {
            (Foo::A(v), SwitchMode::A) => {
                Foo::A(v)
            }
            (Foo::B(v), SwitchMode::A) => {
                Foo::A(v)
            }

            (Foo::B(v), SwitchMode::B) => {
                Foo::B(v)
            }
            (Foo::A(v), SwitchMode::B) => {
                Foo::B(v)
            }
            _ => panic!("Invalid state transition")
        }
    }

    fn debug(&mut self) {
        // debugging
        match &self {
            Foo::A(v) => println!("Foo::A: {:?}", v),
            Foo::B(v) => println!("Foo::B: {:?}", v)
        }
    }
}

fn main() {
    println!("GUD NUF");

    let mut f = Foo::A(Box::new(3));
    let mode = f.update();
    f.debug();
    f = f.switch_mode(mode);
    f.debug();
}