#enum #derive #enums

macro derive-enum-from-into

Derive for From and TryInto for enums with single fields

2 releases

0.1.1 Jan 18, 2022
0.1.0 Jan 3, 2022

#640 in Rust patterns

Download history 18/week @ 2022-06-04 2/week @ 2022-06-11 3/week @ 2022-06-18 2/week @ 2022-06-25 7/week @ 2022-07-02 5/week @ 2022-07-09 3/week @ 2022-07-16 5/week @ 2022-07-23 2/week @ 2022-07-30 14/week @ 2022-08-06 15/week @ 2022-08-13 39/week @ 2022-08-20 520/week @ 2022-08-27 389/week @ 2022-09-03 335/week @ 2022-09-10 372/week @ 2022-09-17

1,640 downloads per month

MIT license

13KB
241 lines

Derive enum from try into

Implements From and TryInto for enums

use derive_enum_from_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<i32, _> = Enum1::B.try_into();
assert!(num.is_err());

Ignores variants with duplicate type definitions or named fields

use derive_enum_from_into::{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<String, _> = Enum1::A("Hello".to_owned()).try_into();
let enum1: Result<bool, _> = (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]

use derive_enum_from_into::{EnumFrom, EnumTryInto};
use std::convert::TryInto;

#[derive(EnumTryInto, PartialEq, Debug)]
#[try_into_references(&, &mut, owned)]
enum NumberOrString {
    Number(f32),
    #[try_into_ignore]
    String(String)
}

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

// This won't compile as cannot TryInto String
// assert!(TryInto::<String>::try_into(NumberOrString::String("Hello World".to_owned())).is_err());

// `TryInto` comes in handy for `filter_map` cases
fn filter_only_f32s(iter: impl Iterator<Item=NumberOrString>) -> impl Iterator<Item=f32> {
    iter.filter_map(|item| item.try_into().ok())
}

// `TryInto` returns `self` if it does not match
assert_eq!(TryInto::<f32>::try_into(NumberOrString::String("Hello World".to_owned())), Err(NumberOrString::String("Hello World".to_owned())));

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

#[derive(derive_enum_from_into::EnumTryInto)]
enum X {
    Leaf(i32),
    Nested(X)
}

Dependencies

~220–630KB
~15K SLoC