5个不稳定版本
| 0.3.1 | 2021年12月22日 |
|---|---|
| 0.3.0 | 2021年12月18日 |
| 0.2.1 | 2021年4月23日 |
| 0.2.0 | 2020年1月13日 |
| 0.1.0 | 2020年1月10日 |
#1993 在 Proc宏
2,878 每月下载量
33KB
513 行
枚举变体类型
从枚举变体生成结构的proc宏推导。
这是对https://github.com/rust-lang/rfcs/pull/2593的简化实现。
[dependencies]
enum_variant_type = "0.3.1"
示例
use enum_variant_type::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 { field_0: u32, field_1: u64 },
/// Skipped variant.
#[evt(skip)]
Skipped,
}
// Now you can do the following:
use core::convert::TryFrom;
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);
// If the enum variant doesn't match the variant type, then the original variant is returned in
// the `Result`'s `Err` variant.
assert_eq!(Err(MyEnum::Unit), Tuple::try_from(MyEnum::Unit));
生成的代码
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 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 variant.
# Unit,
# /// Tuple variant.
# Tuple(u32, u64),
# /// Struct variant.
# Struct {
# field_0: u32,
# field_1: u64,
# },
# }
#
由枚举上的evt属性指定的附加选项
#[evt(derive(Clone, Copy))]导出的Clone、Copy在每一个变体上。#[evt(module = "module1")]：生成的结构体被放置在mod module1 { ... }中。#[evt(implement_marker_traits(MarkerTrait1))]：生成的结构体都实现了impl MarkerTrait1。
许可证
许可协议为以下之一
- Apache License，版本2.0，（LICENSE-APACHE 或 https://apache.ac.cn/licenses/LICENSE-2.0）
- MIT 协议（LICENSE-MIT 或 https://opensource.org/licenses/MIT）
任选其一。
贡献
除非您明确声明，否则根据 Apache-2.0 许可证定义的，您有意提交的、旨在包含在本作品中的任何贡献，将按上述方式双许可，不附加任何额外的条款或条件。
依赖项
~1.5MB
~37K SLoC