Crates.io docs.rs CI Coverage Status

Enum Variant Type

Proc macro derive to generate structs from enum variants.

This is a poor-man's implementation of https://github.com/rust-lang/rfcs/pull/2593.

toml [dependencies] enum_variant_type = "0.3.1"

Examples

```rust,edition2018 use enumvarianttype::EnumVariantType;

[derive(Debug, EnumVariantType, PartialEq)]

pub enum MyEnum { /// Unit variant. #[evt(derive(Clone, Copy, Debug, PartialEq))] Unit, /// Tuple variant. #[evt(derive(Debug, PartialEq))] Tuple(u32, u64), /// Struct variant. #[evt(derive(Debug))] Struct { field0: u32, field1: u64 }, /// Skipped variant. #[evt(skip)] Skipped, }

// Now you can do the following: use core::convert::TryFrom; let unit: Unit = Unit::tryfrom(MyEnum::Unit).unwrap(); let tuple: Tuple = Tuple::tryfrom(MyEnum::Tuple(12, 34)).unwrap(); let named: Struct = Struct::tryfrom(MyEnum::Struct { field0: 12, field_1: 34, }) .unwrap();

let enumunit = MyEnum::from(unit); let enumtuple = MyEnum::from(tuple); let enum_struct = MyEnum::from(named);

// If the enum variant doesn't match the variant type, then the original variant is returned in // the Result's Err variant. asserteq!(Err(MyEnum::Unit), Tuple::tryfrom(MyEnum::Unit)); ```

Generated code

```rust,edition2018 use core::convert::TryFrom;

/// Unit variant.

[derive(Clone, Copy, Debug, PartialEq)]

pub struct Unit;

/// Tuple variant.

[derive(Debug, PartialEq)]

pub struct Tuple(pub u32, pub u64);

/// Struct variant.

[derive(Debug)]

pub struct Struct { pub field0: u32, pub field1: u64, }

impl From for MyEnum { fn from(variant_struct: Unit) -> Self { MyEnum::Unit } }

impl TryFrom for Unit { type Error = MyEnum; fn tryfrom(enumvariant: MyEnum) -> Result { if let MyEnum::Unit = enumvariant { Ok(Unit) } else { Err(enumvariant) } } }

impl From for MyEnum { fn from(variantstruct: Tuple) -> Self { let Tuple(0, 1) = variantstruct; MyEnum::Tuple(_0, _1) } }

impl TryFrom for Tuple { type Error = MyEnum; fn tryfrom(enumvariant: MyEnum) -> Result { if let MyEnum::Tuple(0, _1) = enumvariant { Ok(Tuple(0, _1)) } else { Err(enumvariant) } } }

impl From for MyEnum { fn from(variantstruct: Struct) -> Self { let Struct { field0, field1 } = variantstruct; MyEnum::Struct { field0, field1 } } }

impl TryFrom for Struct { type Error = MyEnum; fn tryfrom(enumvariant: MyEnum) -> Result { if let MyEnum::Struct { field0, field1 } = enumvariant { Ok(Struct { field0, field1 }) } else { Err(enumvariant) } } }

pub enum MyEnum {

/// Unit variant.

Unit,

/// Tuple variant.

Tuple(u32, u64),

/// Struct variant.

Struct {

field_0: u32,

field_1: u64,

},

}

# ```

Additional options specified by an evt attribute on enum:

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.