derive Support for primitive enums

[ryan-summers]

It would be beneficial to be able to derive Encode and Decode for primitive enums (C-like enums) with a specified repr:

#[derive(Encode, Decode)]
#[repr(u8)]
enum States {
    Starting = 0,
    Idle = 1,
    Active = 2,
}

Currently, the derive only works for structs and internally panics on simple enums.

There's some difficulties here:

1. Complex enums could theoretically be supported by treating internal enum data as a struct, but this starts getting into the land of "how do we specify exactly how data should be laid out"
2. What happens if the user doesn't specify a repr? Do we default to e.g. u32?

[ryankurte]

hmm, that does seem like it'd be useful, i guess with similar consideration as to how one would support bitflags or modular-bitfield. i wonder if there's a way to blanket impl for these, but i -think- anything over TryFrom<T> + Into<T> primitives would end up conflicting with the existing impls...

Complex enums could theoretically be supported by treating internal enum data as a struct, but this starts getting into the land of "how do we specify exactly how data should be laid out"

i think if you need to specify weird enum struct storage advice would be to manually implement Encode and Decode?

What happens if the user doesn't specify a repr? Do we default to e.g. u32?

the macro is going to need to pick up the repr tag to implement the correct Encode/Decode, so, how about just failing out if it's not set? i'd rather not compile an ambiguous case than replicate the nightmare of compiler / architecture / optimisation specific enum widths in C/C++.