#enum #tuple #macro #proc-macro #accessor #inner

macro enum-as-inner

A proc-macro for deriving inner field accessor functions on enums

11 unstable releases (4 breaking)

0.5.1 Aug 6, 2022
0.5.0 May 23, 2022
0.4.0 Feb 26, 2022
0.3.3 Aug 8, 2020
0.2.1 Dec 9, 2018

#38 in Procedural macros

Download history 149886/week @ 2022-12-04 148542/week @ 2022-12-11 120281/week @ 2022-12-18 75332/week @ 2022-12-25 125076/week @ 2023-01-01 153971/week @ 2023-01-08 147281/week @ 2023-01-15 143503/week @ 2023-01-22 182126/week @ 2023-01-29 178878/week @ 2023-02-05 165912/week @ 2023-02-12 157338/week @ 2023-02-19 167140/week @ 2023-02-26 183270/week @ 2023-03-05 178172/week @ 2023-03-12 180907/week @ 2023-03-19

722,200 downloads per month
Used in 989 crates (42 directly)

MIT/Apache

16KB
249 lines

enum-as-inner

A deriving proc-macro for generating functions to automatically give access to the inner members of enum.

Basic unnamed field case

The basic case is meant for single item enums, like:

use enum_as_inner::EnumAsInner;

#[derive(Debug, EnumAsInner)]
enum OneEnum {
    One(u32),
}

where the inner item can be retrieved with the as_*()/as_*_mut() or with the into_*() functions:

let one = OneEnum::One(1);

assert_eq!(*one.as_one().unwrap(), 1);
assert_eq!(one.into_one().unwrap(), 1);

let mut one = OneEnum::One(2);

assert_eq!(*one.as_one().unwrap(), 1);
assert_eq!(*one.as_one_mut().unwrap(), 1);
assert_eq!(one.into_one().unwrap(), 1);

where the result is either a reference for inner items or a tuple containing the inner items.

Unit case

This will return true if enum's variant matches the expected type

use enum_as_inner::EnumAsInner;

#[derive(EnumAsInner)]
enum UnitVariants {
    Zero,
    One,
    Two,
}

let unit = UnitVariants::Two;

assert!(unit.is_two());

Mutliple, unnamed field case

This will return a tuple of the inner types:

use enum_as_inner::EnumAsInner;

#[derive(Debug, EnumAsInner)]
enum ManyVariants {
    One(u32),
    Two(u32, i32),
    Three(bool, u32, i64),
}

And can be accessed like:

let mut many = ManyVariants::Three(true, 1, 2);

assert_eq!(many.as_three().unwrap(), (&true, &1_u32, &2_i64));
assert_eq!(many.as_three_mut().unwrap(), (&mut true, &mut 1_u32, &mut 2_i64));
assert_eq!(many.into_three().unwrap(), (true, 1_u32, 2_i64));

Multiple, named field case

This will return a tuple of the inner types, like the unnamed option:

use enum_as_inner::EnumAsInner;

#[derive(Debug, EnumAsInner)]
enum ManyVariants {
    One{ one: u32 },
    Two{ one: u32, two: i32 },
    Three{ one: bool, two: u32, three: i64 },
}

And can be accessed like:

let mut many = ManyVariants::Three{ one: true, two: 1, three: 2 };

assert_eq!(many.as_three().unwrap(), (&true, &1_u32, &2_i64));
assert_eq!(many.as_three_mut().unwrap(), (&mut true, &mut 1_u32, &mut 2_i64));
assert_eq!(many.into_three().unwrap(), (true, 1_u32, 2_i64));

Dependencies

~0.7–1.1MB
~27K SLoC