match-commutative ↔️

Match on patterns commutatively, reducing the use of duplicated patterns.

Documentation

Motivation

When you need to match on three values that form a commutative math relation, you often need to duplicate a lot of patterns. Let's look at an example of what this might look like:

```rust // imagine that these values come from somewhere and we need to match on them let operant1 = Operant::Str(Some("42".into())); let operant2 = Operant::Num(Some(1)); let operator = Operator::Plus;

match (operant1, operator, operant2) { ( Operant::Str(Some(operantstr)), Operator::Plus, Operant::Num(Some(operantnum)), ) | ( Operant::Num(Some(operantnum)), Operator::Plus, Operant::Str(Some(operantstr)), ) => { let result = operantnum + operantstr.parse::().unwrap(); println!("Result is: {}", result); } ( Operant::Str(Some(operantstr)), Operator::Mult, Operant::Num(Some(operantnum)), ) | ( Operant::Num(Some(operantnum)), Operator::Mult, Operant::Str(Some(operantstr)), ) => { let result = operantnum * operantstr.parse::().unwrap(); println!("Result is: {}", result); } (_, _, _) => { panic!("Not relevant for this example") } }

// Types that we use in this example enum Operant { Str(Option), Num(Option), }

enum Operator { Plus, Mult, Minus, } ``For bothOperator::{Plus, Mult}, we have to write _two patterns each_ that are exactly identical (and connect them with|(or-pattern)) and execute the same logic. The only difference in the pattern is the ordering of theOperant`. Not nice!

Using `match-commutative` instead

With match-commutative this can be simplified to: ```rust use matchcommutative::matchcommutative; // imagine that these values come from somewhere and we need to match on them let operant1 = Operant::Str(Some("42".into())); let operant2 = Operant::Num(Some(1)); let operator = Operator::Plus;

matchcommutative!( operant1, operator, operant2, Operant::Str(Some(operantstr)), Operator::Plus, Operant::Num(Some(operantnum)) => { let result = operantnum + operantstr.parse::().unwrap(); println!("Result is: {}", result); }, Operant::Str(Some(operantstr)), Operator::Mult, Operant::Num(Some(operantnum)) => { let result = operantnum * operantstr.parse::().unwrap(); println!("Result is: {}", result); } noncommut { _, _, _ => { // in non_commut block, patterns and their execution block behave exactly like std Rust panic!("Not relevant for this example") } } );

// Types that we use in this example enum Operant { Str(Option), Num(Option), }

enum Operator { Plus, Mult, Minus, } ``Note that in the above example the values ofoperant1andoperant2could have been swapped, __while still leading to the same program output.__ So we have successfully avoided the expression of _ordering_ in our patterns (where ordering is not needed between twoOperant`s).✨

Getting Started

In your Cargo.toml file add the following lines under [dependencies]: toml match-commutative = "0.1.0-alpha.0"

Safety

This crate is implemented in 100% Safe Rust, which is ensured by using #![forbid(unsafe_code)].

MSRV

The Minimum Supported Rust Version for this crate is 1.54. An increase of MSRV will be indicated by a minor change (according to SemVer).

License

^{Licensed under either of Apache License, Version
2.0 or MIT license at your option.}

_{Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
be dual licensed as above, without any additional terms or conditions.}