Macro alias_option

Source

macro_rules! alias_option {
    ($type_name:ident, $some_variant:ident, $none_variant:ident) => { ... };
    ($type_name:ident, $some_variant:ident, $none_variant:ident, traits: [$($trait:path),*]) => { ... };
    ($type_name:ident, $some_variant:ident, $none_variant:ident, implement_try) => { ... };
    ($type_name:ident, $some_variant:ident, $none_variant:ident, traits: [$($trait:path),*], implement_try) => { ... };
    ($type_name:ident, $some_variant:ident, $none_variant:ident, [$($trait:path),*]) => { ... };
    ($type_name:ident, $some_variant:ident, $none_variant:ident, [$($trait:path),*], $($implement_try:ident)?) => { ... };
}

Expand description

Creates an Option-like enum with custom variant names.

See examples::OptionExample for a generated example.

§Example

use enumizer::alias_option;

alias_option!(Value, Found, Searching);

let searching: Value<i32> = Value::Searching;
let found = Value::Found(42);

assert!(searching.is_searching());
assert!(!searching.is_found());
assert!(found.is_found());
assert_eq!(found.as_found(), Some(&42));

§Generated Methods

use enumizer::alias_option;
alias_option!(Value, Found, Searching);
let mut val = Value::Found(10);

// Check variants
assert!(val.is_found());

// Get references
assert_eq!(val.as_found(), Some(&10));
assert_eq!(val.as_found_mut(), Some(&mut 10));

// Transform
let doubled = val.map(|x| x * 2);
assert_eq!(doubled.unwrap(), 20);

// Unwrap variants
assert_eq!(Value::Found(5).unwrap_or(0), 5);
assert_eq!(Value::<i32>::Searching.unwrap_or(5), 5);

§Conversions

The generated type can be easily converted to and from Option<T>.

use enumizer::alias_option;
alias_option!(Value, Found, Searching);
let from_some: Value<i32> = Some(42).into();
let from_none: Value<i32> = None.into();

assert_eq!(from_some, Value::Found(42));
assert_eq!(from_none, Value::Searching);

let to_option: Option<i32> = Value::Found(42).into();
assert_eq!(to_option, Some(42));

§Conditional Checks

use enumizer::alias_option;
alias_option!(Value, Found, Searching);
let val = Value::Found(42);
assert!(val.is_found_and(|&x| x > 40));
assert!(!val.is_found_and(|&x| x < 40));
assert!(!Value::<i32>::Searching.is_found_and(|&x| x > 40));

assert!(Value::<i32>::Searching.is_searching_or(|&x| x > 40));
assert!(val.is_searching_or(|&x| x > 40));
assert!(!val.is_searching_or(|&x| x < 40));

§Custom Traits

You can specify custom traits to derive instead of the default set. Use the traits: keyword followed by a list of trait names in brackets.

use enumizer::alias_option;
alias_option!(CustomOption, Present, Absent, traits: [Debug, Clone, serde::Serialize, serde::Deserialize]);
let val = CustomOption::Present(42);
assert_eq!(format!("{:?}", val), "Present(42)");
assert_eq!(val.clone().unwrap(), 42);
let json = serde_json::to_string(&val).unwrap();
assert_eq!(json, r#"{"Present":42}"#);

§Try Trait Support (Nightly Only)

Add implement_try to enable the ? operator for early returns. Requires nightly Rust with #![feature(try_trait_v2)].

#![feature(try_trait_v2)]
use enumizer::alias_option;

alias_option!(Value, Found, Searching, implement_try);

fn try_example(val1: Value<i32>, val2: Value<i32>) -> Value<i32> {
    let x = val1?;
    let y = val2?;
    Value::Found(x + y)
}

assert_eq!(try_example(Value::Found(10), Value::Found(20)), Value::Found(30));
assert_eq!(try_example(Value::Searching, Value::Found(20)), Value::Searching);

alias_option