Macro alias_result 

macro_rules! alias_result {
    ($type_name:ident, $ok_variant:ident, $err_variant:ident) => { ... };
    ($type_name:ident, $ok_variant:ident, $err_variant:ident, traits: [$($trait:path),*]) => { ... };
    ($type_name:ident, $ok_variant:ident, $err_variant:ident, implement_try) => { ... };
    ($type_name:ident, $ok_variant:ident, $err_variant:ident, traits: [$($trait:path),*], implement_try) => { ... };
    ($type_name:ident, $ok_variant:ident, $err_variant:ident, [$($trait:path),*]) => { ... };
    ($type_name:ident, $ok_variant:ident, $err_variant:ident, [$($trait:path),*], $($implement_try:ident)?) => { ... };
}

Creates a Result-like enum with custom variant names.

See examples::ResultExample for a generated example.

Example

use enumizer::alias_result;

alias_result!(Response, Success, Failure);

let success: Response<i32, String> = Response::Success(42);
let error: Response<i32, String> = Response::Failure("failed".to_string());

assert!(success.is_success());
assert!(error.is_failure());
assert_eq!(success.as_success(), Some(&42));

Generated Methods

use enumizer::alias_result;
alias_result!(Response, Success, Failure);
let mut val: Response<i32, String> = Response::Success(10);

assert!(val.is_success());
assert_eq!(val.as_success(), Some(&10));
assert_eq!(val.as_failure(), None);

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

Conversions

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

use enumizer::alias_result;
alias_result!(Response, Success, Failure);
let from_ok: Response<i32, String> = Ok(42).into();
let from_err: Response<i32, String> = Err("failed".to_string()).into();

assert_eq!(from_ok, Response::Success(42));
assert!(from_err.is_failure());

let to_result: Result<i32, String> = Response::Success(42).into();
assert_eq!(to_result, Ok(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_result;

alias_result!(Response, Success, Failure, implement_try);

fn try_example(res1: Response<i32, String>, res2: Response<i32, String>) -> Response<i32, String> {
    let x = res1?;
    let y = res2?;
    Response::Success(x * y)
}

assert_eq!(try_example(Response::Success(5), Response::Success(15)), Response::Success(75));
assert_eq!(try_example(Response::Failure("error".into()), Response::Success(15)), Response::Failure("error".into()));

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_result;
alias_result!(CustomResult, Ok, Err, traits: [Debug, Clone, serde::Serialize, serde::Deserialize]);
let val: CustomResult<i32, String> = CustomResult::Ok(42);
assert_eq!(format!("{:?}", val), "Ok(42)");
assert_eq!(val.clone().unwrap(), 42);
let json = serde_json::to_string(&val).unwrap();
assert_eq!(json, r#"{"Ok":42}"#);