#pattern-matching #pattern #match #enums #macro #variant

no-std try_match

Fallible pattern matching with a function-like syntax

9 releases

0.4.2 Jul 25, 2024
0.4.1 May 18, 2023
0.3.0 Oct 28, 2021
0.2.3 Oct 26, 2021
0.1.0 Oct 20, 2019

#172 in Rust patterns

Download history 8789/week @ 2024-08-20 9717/week @ 2024-08-27 9012/week @ 2024-09-03 8293/week @ 2024-09-10 7097/week @ 2024-09-17 8774/week @ 2024-09-24 7440/week @ 2024-10-01 7371/week @ 2024-10-08 7818/week @ 2024-10-15 8939/week @ 2024-10-22 8288/week @ 2024-10-29 12349/week @ 2024-11-05 10989/week @ 2024-11-12 13101/week @ 2024-11-19 9856/week @ 2024-11-26 9517/week @ 2024-12-03

44,756 downloads per month
Used in 28 crates (6 directly)

MIT/Apache

24KB
151 lines

try_match

docs.rs

Fallible pattern matching with a function-like syntax

Basic Usage

Macros

use try_match::{try_match, match_ok, unwrap_match};

#[derive(Copy, Clone, Debug, PartialEq)]
enum Enum { Var0, Var1(i32), Var2(i32, i32) }

use Enum::*;

// `try_match!` returns `Result`: `Ok(bindings)` on success or
// `Err(input_value)` otherwise
assert_eq!(try_match!(Var1(42), Var1(x)), Ok(42));
assert_eq!(try_match!(Var0,     Var1(x)), Err(Var0));

// `match_ok!` returns `Option`
assert_eq!(match_ok!(Var1(42), Var1(x)), Some(42));
assert_eq!(match_ok!(Var0,     Var1(x)), None);

// `match_or_default!` returns a default value on failure
assert_eq!(match_or_default!(Var1(42), Var1(x)), 42);
assert_eq!(match_or_default!(Var0,     Var1(x)), 0);

// `unwrap_match!` panics on failure:
assert_eq!(unwrap_match!(Var1(42), Var1(x)), 42);
        /* unwrap_match!(Var0,     Var1(x)); */ // this will panic

Match guards (if <expr>) are supported:

assert_eq!(match_ok!(Var1(42), Var1(x)),           Some(42));
assert_eq!(match_ok!(Var1(42), Var1(x) if x < 20), None);

Bindings

// Returns `()` (wrapped by `Ok(_)`) if there are no bound variables
assert_eq!(unwrap_match!(Var1(42), Var1(_)), ());

// ... the bound value if there is exactly one binding
assert_eq!(unwrap_match!(Var1(42), Var1(x)), 42);

// ... an anonymous struct if there are multiple bindings
let vars = unwrap_match!(Var2(12, 34), Var2(a, b));
assert_eq!((vars.a, vars.b), (12, 34));

// ... or a tuple if the binding names are numeric
let (a, b) = unwrap_match!(Var2(12, 34), Var2(_0, _1));
assert_eq!((a, b), (12, 34));

// An optional `=>` clause specifies an explicit mapping
assert_eq!(unwrap_match!(Var1(42), Var1(x) => x + 1), 43);
assert_eq!(unwrap_match!(Var0,     Var0    => "yay"), "yay");

Partial Application

// Omit the scrutinee expression to produce a closure
let _:             Option<i32> = match_ok!(Var1(42), Var1(x));
let _: fn(Enum) -> Option<i32> = match_ok!(        , Var1(x));

Applications

Iterator::filter_map

let array = [Var1(42), Var0, Var1(10)];
let filtered: Vec<_> = array
    .iter()
    .filter_map(match_ok!(, &Var1(_0) if _0 > 20))
    .collect();
assert_eq!(filtered, [42]);

Iterator::map + Fallible Iterator::collect

let array = [Var1(42), Var0, Var1(10)];
let filtered: Result<Vec<_>, _> = array
    .iter()
    .map(try_match!(, &Var1(_0) if _0 > 20))
    .collect();

// `Var0` is the first value that doesn't match
assert_eq!(filtered, Err(&Var0));

Extract Variants

impl Enum {
    fn var1(&self) -> Option<&i32> {
        match_ok!(self, Var1(_0))
    }

    fn is_var2(&self) -> bool {
        matches!(self, Var0)
    }
}

let enums = [Var1(42), Var0];
assert_eq!(enums[0].var1(), Some(&42));
assert_eq!(enums[1].var1(), None);

assert!(!enums[0].is_var2());
assert!(enums[1].is_var2());

Expect Certain Variants

fn this_fn_expects_var2(foo: &Enum) {
    let i = unwrap_match!(foo, &Var2(42, _0));

    // Alternatively, you could use let-else (stabilized in Rust 1.65.0):
    // let &Var2(42, i) = foo else { panic!("{foo:?}") };

    assert_eq!(i, 84);
}

this_fn_expects_var2(&Var2(42, 84));

matcher::matches! (now incorporated into the standard library as core::matches!) is similar but only returns bool indicating whether matching was successful or not.

let success1 =  matches!(Some(42), Some(_));
let success2 = match_ok!(Some(42), Some(_)).is_some();
assert_eq!(success1, success2);

bind_match::bind_match! and extract::extract! behave in the same way as match_ok! except for the lack of implicit mapping and partial application.

variant::get_variant! from the extract_variant crate offers a similar functionality to match_ok!. It supports implicit mapping but uses different rules to handle multiple bindings.

License

MIT/Apache-2.0

Dependencies

~98KB