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.
Examples
use std::convert::TryFrom;
use enum_variant_type::EnumVariantType;
#[derive(Debug, EnumVariantType, PartialEq)]
pub enum MyEnum {
#[evt_attrs(derive(Clone, Copy, Debug, PartialEq))]
Unit,
#[evt_attrs(derive(Debug, PartialEq))]
Tuple(u32, u64),
#[evt_attrs(derive(Debug))]
Struct {
field_0: u32,
field_1: u64,
},
}
let unit: Unit = Unit::try_from(MyEnum::Unit).unwrap();
let tuple: Tuple = Tuple::try_from(MyEnum::Tuple(12, 34)).unwrap();
let named: Struct = Struct::try_from(MyEnum::Struct { field_0: 12, field_1: 34 }).unwrap();
let enum_unit = MyEnum::from(unit);
let enum_tuple = MyEnum::from(tuple);
let enum_struct = MyEnum::from(named);
assert_eq!(Err(MyEnum::Unit), Tuple::try_from(MyEnum::Unit));
use std::convert::TryFrom;
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Unit;
#[derive(Debug, PartialEq)]
pub struct Tuple(pub u32, pub u64);
#[derive(Debug)]
pub struct Struct {
pub field_0: u32,
pub field_1: u64,
}
impl From<Unit> for MyEnum {
fn from(variant_struct: Unit) -> Self {
MyEnum::Unit
}
}
impl TryFrom<MyEnum> for Unit {
type Error = MyEnum;
fn try_from(enum_variant: MyEnum) -> Result<Self, Self::Error> {
if let MyEnum::Unit = enum_variant {
Ok(Unit)
} else {
Err(enum_variant)
}
}
}
impl From<Tuple> for MyEnum {
fn from(variant_struct: Tuple) -> Self {
let Tuple(_0, _1) = variant_struct;
MyEnum::Tuple(_0, _1)
}
}
impl TryFrom<MyEnum> for Tuple {
type Error = MyEnum;
fn try_from(enum_variant: MyEnum) -> Result<Self, Self::Error> {
if let MyEnum::Tuple(_0, _1) = enum_variant {
Ok(Tuple(_0, _1))
} else {
Err(enum_variant)
}
}
}
impl From<Struct> for MyEnum {
fn from(variant_struct: Struct) -> Self {
let Struct { field_0, field_1 } = variant_struct;
MyEnum::Struct { field_0, field_1 }
}
}
impl TryFrom<MyEnum> for Struct {
type Error = MyEnum;
fn try_from(enum_variant: MyEnum) -> Result<Self, Self::Error> {
if let MyEnum::Struct { field_0, field_1 } = enum_variant {
Ok(Struct { field_0, field_1 })
} else {
Err(enum_variant)
}
}
}
# pub enum MyEnum {
# # Unit,
# # Tuple(u32, u64),
# # Struct {
# field_0: u32,
# field_1: u64,
# },
# }
#
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.