#enums #inner #deriving #access #automatic #field #accessor

macro enum-as-inner

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

12 releases

0.6.0 May 30, 2023
0.5.1 Aug 6, 2022
0.5.0 May 23, 2022
0.4.0 Feb 26, 2022
0.2.1 Dec 9, 2018

#33 in Procedural macros

Download history 290336/week @ 2023-12-12 229873/week @ 2023-12-19 117079/week @ 2023-12-26 247598/week @ 2024-01-02 257774/week @ 2024-01-09 295312/week @ 2024-01-16 305247/week @ 2024-01-23 319879/week @ 2024-01-30 328505/week @ 2024-02-06 314637/week @ 2024-02-13 310005/week @ 2024-02-20 343592/week @ 2024-02-27 337908/week @ 2024-03-05 336582/week @ 2024-03-12 337706/week @ 2024-03-19 280843/week @ 2024-03-26

1,357,535 downloads per month
Used in 1,370 crates (82 directly)

MIT/Apache

17KB
265 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

~345–790KB
~19K SLoC