Derive enum from try into

Implements From and TryInto for enums

```rust use deriveenumfrom_into::{EnumFrom, EnumTryInto}; use std::convert::TryInto;

[derive(EnumFrom, EnumTryInto, PartialEq, Debug)]

enum Enum1 { A(i32), B, }

assert_eq!( Enum1::from(54i32), Enum1::A(54i32) );

let num: Result = Enum1::B.tryinto(); assert!(num.iserr()); ```

Ignores variants with duplicate type definitions or named fields

```compileerror use deriveenumfrominto::{EnumFrom, EnumTryInto}; use std::convert::TryInto;

[derive(EnumFrom, EnumTryInto, PartialEq, Debug)]

enum Enum1 { A(String), B(String), C { something: bool }, }

// Results in compile errors let enum1: Result = Enum1::A("Hello".toowned()).tryinto(); let enum1: Result = (Enum1::C { something: true }).try_into(); ```

From can be ignored for variants with #[from_ignore]

TryInto can also be implemented for references of the enum. Specific variants can be ignored with #[try_into_ignore]

```rust use deriveenumfrom_into::{EnumFrom, EnumTryInto}; use std::convert::TryInto;

[derive(EnumTryInto, PartialEq, Debug)]

[tryintoreferences(&, &mut, owned)]

enum NumberOrString { Number(f32), #[tryintoignore] String(String) }

let x = NumberOrString::Number(4.); asserteq!(TryInto::<&f32>::tryinto(&x), Ok(&4.));

// This won't compile as cannot TryInto String // assert!(TryInto::::tryinto(NumberOrString::String("Hello World".toowned())).is_err());

// TryInto comes in handy for filter_map cases fn filteronlyf32s(iter: impl Iterator) -> impl Iterator { iter.filtermap(|item| item.tryinto().ok()) }

// TryInto returns self if it does not match asserteq!(TryInto::::tryinto(NumberOrString::String("Hello World".toowned())), Err(NumberOrString::String("Hello World".toowned()))); ```

Note that because of the default implementation of TryInto the following will not compile. There are workarounds with wrapping X in a newtype pattern

```compile_error

[derive(deriveenumfrom_into::EnumTryInto)]

enum X { Leaf(i32), Nested(X) } ```