Lib.rs

#[penum( impl From<bool> for {f32,f64} )]

简单示例

使用 Penum 自动 实现 枚举的特质。

#[penum(impl String: ^AsRef<str>)]
enum Store {
    V0(),
    V1(i32),
    V2(String, i32),
    V3(i32, usize, String),
    V4(i32, String, usize),
    V5 { age: usize, name: String },
    V6,
}

• 将变为这样

impl AsRef<str> for Store {
    fn as_ref(&self) -> &str {
        match self {
            Store::V2(val, ..) => val.as_ref(),
            Store::V3(_, _, val) => val.as_ref(),
            Store::V4(_, val, ..) => val.as_ref(),
            Store::V5 { name, .. } => name.as_ref(),
            _ => "",
        }
    }
}

也支持用户自定义特质，但请确保它们在枚举之前被标记。

#[penum]
trait Trait {
    fn method(&self, text: &str) -> &Option<&str>;
}

Penum 足够智能，可以推断非匹配变体的某些返回类型。例如 Option<T>、&Option<T>、String、&str。它甚至可以处理 &String、引用非常量类型。目标是支持任何类型，我们可能通过检查实现 Default 特质的类型来实现。

注意，在分派具有关联类型的特质时，声明它们很重要。例如 Add<i32, Output = i32>。

示例

使用 penum 强制每个变体都成为具有一个字段（该字段必须实现 Trait）的元组。

#[penum( (T, ..) where T: Trait )]
enum Guard {
    Bar(String), 
        ^^^^^^
    // ERROR: `String` doesn't implement `Trait`

    Bor(Option<String>), 
        ^^^^^^^^^^^^^^
    // ERROR: `Option<String>` doesn't implement `Trait`

    Bur(Vec<String>), 
        ^^^^^^^^^^^
    // ERROR: `Vec<String>` doesn't implement `Trait`

    Byr(), 
    ^^^^^
    // ERROR: `Byr()` doesn't match pattern `(T)`

    Bxr { name: usize }, 
        ^^^^^^^^^^^^^^^
    // ERROR: `{ nname: usize }` doesn't match pattern `(T)`

    Brr,
    ^^^
    // ERROR: `Brr` doesn't match pattern `(T)`

    Bir(i32, String), // Works!
    Beer(i32)         // Works!
}

如果你不关心实际的模式匹配，则可以使用 _ 自动推断每个形状和字段。结合具体的分派类型，你就得到了一个自动分派器。

#[penum( _ where Ce: ^Special, Be: ^AsInner<i32> )]
enum Foo {
    V1(Al),
    V2(i32, Be),
    V3(Ce),
    V4 { name: String, age: Be },
}

// Will create these implementations
impl Special for Foo {
    fn ret(&self) -> Option<&String> {
        match self {
            Foo::V3(val) => val.ret(),
            _ => None,
        }
    }
}

impl AsInner<i32> for Foo {
    fn as_inner(&self) -> &i32 {
        match self {
            Foo::V2(_, val) => val.as_inner(),
            Foo::V4 { age, .. } => age.as_inner(),
            _ => &0,
        }
    }
}

• 它与这个相同

#[penum(impl Ce: ^Special, Be: ^AsInner<i32>)]

更多详情

• Impls —— 可以被视为实现此特性的具体类型的缩写，主要用作常规泛型特性边界的替代。它们看起来像这样，(impl Copy, impl Copy) | {name: impl Clone}

• 占位符 —— 是单个无界通配符，如果你熟悉Rust，那就是下划线标识符_，通常表示忽略某个东西，这意味着它们将满足任何类型(_, _) | {num: _}。

• 可变参数 —— 与占位符类似，但它们不仅能替换一个类型，还可以替换0个或多个类型。与占位符一样，它们是一种表达我们不在乎模式中其余参数的方式。它们看起来像这样(T, U, ..) | {num: T, ..}。

#[penum]
enum Enum {
    Variant0(String) = implement! {
        ToString            => "My incoming string: {f0}",
        Deref[Target = str] => &**f0,
        AsRef[str]          => f0,
    },
    default = {
        ToString => "My custom fallback string",
        _ => Default::default()
    }
}

#[penum]
enum Enum {
    Variant0(String) = implement! {
        ToString            => "My incoming string: {f0}",
    },
    Variant1(&'static str, i32) = implement! {
        ToString            => "My incoming string: {f0}",
    },
    default = {
        ToString => "My custom fallback string",
        _ => Default::default()
    }
}

#[penum]
enum Enum {
    Variant0(String) = implement! {
        ToString { 
            format!("My incoming string: {f0}") 
        },
        Deref<Target = str> { 
            &**f0 
        },
        AsRef<str> { f0 },
    },
    default = implement! {
        ToString { "My custom fallback string" },
        _ { Default::default() }
    }
}

#[penum]
enum Enum {
    Variant0(String) = implement! {
        ToString => { 
            format!("My incoming string: {f0}") 
        },
        Deref<Target = str> => { 
            &**f0 
        },
        AsRef<str> => { f0 },
    },
    default = implement! {
        ToString { "My custom fallback string" },
        _ { Default::default() }
    }
}

#[penum]
enum Enum {
    Variant0(String) = implement! {
        ToString => { 
            format!("My incoming string: {f0}") 
        },
        Deref<Target = str> => { 
            &**f0 
        },
        AsRef<str> => { f0 },
    },
    default = implement! {
        ToString => { "My custom fallback string" },
        _  => { Default::default() }
    }
}