#enums #boolean #derive #proc-macro #variant-name

macro boolenum

Derive From<bool> and Into<bool> for your boolean enums

1 unstable release

0.1.0 Jun 19, 2020

#15 in #variant-name

Download history 1377/week @ 2024-03-14 1455/week @ 2024-03-21 1356/week @ 2024-03-28 1623/week @ 2024-04-04 1165/week @ 2024-04-11 1334/week @ 2024-04-18 1867/week @ 2024-04-25 2262/week @ 2024-05-02 1950/week @ 2024-05-09 1431/week @ 2024-05-16 1034/week @ 2024-05-23 1358/week @ 2024-05-30 2002/week @ 2024-06-06 1758/week @ 2024-06-13 2404/week @ 2024-06-20 2226/week @ 2024-06-27

8,703 downloads per month
Used in oq3_semantics

MIT/Apache

8KB
71 lines

boolenum

BoolEnum is a derive macro to create ergonomic boolean enums with less boilerplate. It generates From<bool>, Into<bool> and Not impls for your enum.

use boolenum::BoolEnum;

// Variant names can be Yes and No (in any order) ...
#[derive(BoolEnum)]
enum UseColors {
    No,
    Yes,
}

// or True and False
#[derive(BoolEnum)]
enum ShowExpired {
    True,
    False,
}

fn print_things(use_colors: UseColors, show_expired: ShowExpired) {
    if use_colors.into() { // Into<bool>
      // ...
    }
}

fn main() {
    print_things(UseColors::Yes, ShowExpired::False)
}

Boolean enums are useful for differentiating between boolean arguments to a function, so you can write something like encode(&bytes, Encrypt::Yes, Compress::No) instead of encode(&bytes, true, false).

Goes well with structopt, for type-safe handling of command-line flags:

use boolenum::BoolEnum;
use structopt::StructOpt;

#[derive(BoolEnum)]
enum Verbose { No, Yes }
#[derive(BoolEnum)]
enum Colors { No, Yes }

#[derive(StructOpt)]
struct Opt {
    #[structopt(short, long, parse(from_flag))]
    verbose: Verbose, // works because Verbose implements From<bool>
    #[structopt(short, long, parse(from_flag))]
    colors: Colors,
}

fn main() {
    let opt = Opt::from_args();
    do_thing(opt.verbose, opt.colors);
}

fn do_thing(verbose: Verbose, colors: Colors) {
    if verbose.into() { }
    if colors.into() { }
}

BoolEnum works on enums with two unit variants, named either Yes and No, or True and False. The order of the variants in the enum doesn't matter.

License: MIT OR Apache-2.0

Dependencies

~1.5MB
~36K SLoC