trie_match! {}

Crates.io Documentation Rust Build Status Slack

This macro speeds up Rust's match expression for comparing strings by using a compact double-array data structure.

Usage

Simply wrap the existing match expression with the trie_match! {} macro as follows:

```rust use triematch::triematch;

let x = "abd";

let result = trie_match! { match x { "a" => 0, "abc" => 1, pat @ ("abd" | "bcc") => pat.bytes()[0], "bc" => 3, _ => 4, } };

assert_eq!(result, 3); ```

Why is it faster?

In a normal match expression, the string is compared for each pattern. It is equivalent to the following code:

rust if x == "a" { 0 } else if x == "abc" { 1 } else if x == "abd" || x == "bcc" { x.bytes()[0] } else if x == "bc" { 3 } else { 4 }

The above code requires that string comparisons be made from the beginning of the string each time. The time complexity of the above code is O(mn), where m is the average pattern length, and n is the number of patterns.

In contrast, this macro builds the following trie structure to retrieve the index of the matched arm:

Trie

Furthermore, this implementation uses the compact double-array data structure to achieve efficient state-to-state traversal, and the time complexity becomes O(m).

cfg attribute

Only when using Nightly Rust, this macro supports conditional compilation with the cfg attribute. To use this feature, enable features = ["cfg_attribute"] in your Cargo.toml.

Example

rust trie_match! { match x { #[cfg(feature = "foo")] "a" => { .. } #[cfg(feature = "bar")] "b" => { .. } _ => { .. } } }

Limitations

The followings are different from the normal match expression:

Sometimes the normal match expression is faster, depending on how optimization is performed, so it is better to choose based on your speed experiments.

Benchmark

Run the following command:

cargo bench

Experimental results are as follows [μs]:

phf crate: Compile time static maps using perfect hash functions.

License

Licensed under either of

at your option.

Contribution

See the guidelines.