#cfg #proc-macro #features #token-stream #foo-bar

macro no-std is_not

A procedural macro much like #[cfg(...)] that can be re-exported from a library based on enabled features

1 unstable release

0.1.0 Oct 27, 2020

#591 in Configuration

Download history 183/week @ 2024-03-29 87/week @ 2024-04-05 330/week @ 2024-04-12 126/week @ 2024-04-19 273/week @ 2024-04-26 263/week @ 2024-05-03 190/week @ 2024-05-10 122/week @ 2024-05-17 306/week @ 2024-05-24 430/week @ 2024-05-31 210/week @ 2024-06-07 173/week @ 2024-06-14 121/week @ 2024-06-21 133/week @ 2024-06-28 209/week @ 2024-07-05 276/week @ 2024-07-12

830 downloads per month

MIT/Apache

7KB

is_not

This crate exports two very simple attribute macros. is returns the token stream as is and not returns an empty token stream.

These are very similar to the #[cfg(...)] attributes, but they can be exported from a crate for things that need to be enabled if a dependency has certain features enabled. It additionally has the advantage that it also type checks. If you mis-spell something inside of #[cfg(mis-spelled)] it will always be disabled, where these attributes must exist in the namespace.

For example, let's say you want to allow different algorithms or implementations inside of a library that can be turned on and off and add expensive compile times due to dependencies or will be in the hot path of an application's main loop.

// algo crate
// This crate ensures that at least one of foo and bar is active using a build script or more fancy cfg attributes.

#[cfg(feature = "foo")]
pub use is_not::{is as is_foo, not as not_foo};
#[cfg(not(feature = "foo"))]
pub use is_not::{not as is_foo, is as not_foo};
#[cfg(feature = "bar")]
pub use is_not::{is as is_bar, not as not_bar};
#[cfg(not(feature = "bar"))]
pub use is_not::{not as is_bar, is as not_bar};

#[cfg(feature = "foo")]
mod foo {
    fn foo(a: Foo) -> i32 {
        // algorithm
    }
    struct Foo {
        // fields
    }
}

#[cfg(feature = "foo")]
mod bar {
    fn bar(a: Bar) -> i32 {
        // algorithm
    }
    struct Bar {
        // fields
    }
}
// app crate
// both of these functions will exist, though compile time flags given to the algo crate will change how they are compiled in the app crate.

// You can ensure that at least one is turned on
#[not_foo]
#[not_bar]
compile_error!("Either foo or bar or both should be enabled in algo crate");

#[is_foo]
fn call_foo() -> i32 {
  algo::foo::foo(algo::foo::Foo{})
}

#[not_foo]
fn call_foo() -> i32 {
  call_bar()
}

#[is_bar]
fn call_bar() -> i32 {
  algo::bar::bar(algo::bar::Bar{})
}

#[not_bar]
fn call_bar() -> i32 {
  call_foo()
}

fn call_algo() -> i32 {
  if crate::use_foo() {
    call_foo()
  } else {
    call_bar()
  }
}

No runtime deps