enum-try-from

Rust macros which create enums with TryFrom trait implementation.

Examples

```rust use enumtryinto::implenumtry_from;

implenumtry_from!( #[repr(u16)] #[derive(PartialEq, Eq, Debug)] enum MyEnum { Foo = 0, Bar = 1, Baz = 2, }, u16, (), () );

fn main() { asserteq!(MyEnum::tryfrom(0), Ok(MyEnum::Foo)); asserteq!(MyEnum::tryfrom(1), Ok(MyEnum::Bar)); asserteq!(MyEnum::tryfrom(2), Ok(MyEnum::Baz)); asserteq!(MyEnum::tryfrom(3), Err(())); } ```

```rust use enumtryinto::implenumtry_from; use thiserror::Error;

[derive(Error, Debug, PartialEq, Eq)]

pub enum MyError { #[error("invalid value")] InvalidValue, }

implenumtry_from!( #[repr(u16)] #[derive(PartialEq, Eq, Debug)] enum MyEnum { Foo = 0, Bar = 1, Baz = 2, }, u16, MyError, MyError::InvalidValue ); ```

If the value provided to try_from should be converted from big endian:

```rust use enumtryinto::implenumtryfrombe;

implenumtryfrombe!( #[repr(u16)] #[derive(PartialEq, Eq, Debug)] enum MyEnum { Foo = 0x1234, Bar = 0x5678, Baz = 0x9abc, }, u16, (), () );

fn main() { asserteq!(MyEnum::tryfrom(0x3412), Ok(MyEnum::Foo)); asserteq!(MyEnum::tryfrom(0x7856), Ok(MyEnum::Bar)); asserteq!(MyEnum::tryfrom(0xbc9a), Ok(MyEnum::Baz)); asserteq!(MyEnum::tryfrom(0xdef0), Err(())); } ```

Why does it exist?

Rust projects very often consume values as regular integers and then try to match them with enums. Doing so, requires implementing the TryFrom trait for enums. Example:

```rust

[repr(u16)]

[derive(PartialEq, Eq, Debug)]

enum MyEnum { Foo = 0, Bar = 1, Baz = 2, }

impl TryFrom for MyEnum { type Error = ();

fn try_from(v: u16) -> Result<Self, Self::Error> {
    match v {
        0 => Ok(MyEnum::Foo),
        1 => Ok(MyEnum::Bar),
        2 => Ok(MyEnum::Baz),
        _ => Err(()),
    }
}

}

fn main() { asserteq!(MyEnum::tryfrom(0), Ok(MyEnum::Foo)); asserteq!(MyEnum::tryfrom(1), Ok(MyEnum::Bar)); asserteq!(MyEnum::tryfrom(2), Ok(MyEnum::Baz)); asserteq!(MyEnum::tryfrom(3), Err(())); } ```

It requires listing all enum variants multiple times and also requires writing down new variants multiple times when adding them to the existing enum.

The goal of this crate is to avoid that and define an enum with variants only once.