Struct SimplifiedPatternMatcher 

pub struct SimplifiedPatternMatcher<C = ()> { /* private fields */ }

High-performance pattern matcher with O(1) OpKey-based dispatch.

Design

Instead of a single list of patterns that must be linearly scanned, patterns are indexed by their OpKey in a HashMap. When matching:

1. Extract OpKey from the input UOp
2. Look up patterns for that key (O(1) HashMap lookup)
3. Try only those patterns (typically 1-3 per key)
4. Fall back to wildcard patterns if no match

Type Parameter

• C: Context type passed to all pattern closures. Use () for stateless matching.

Example

Typically used via the patterns! macro:

use morok_macros::patterns;

let matcher = patterns! {
    Add(x, @zero) ~> x,
    Mul(x, @one) ~> x,
};

// Use with graph_rewrite
let result = graph_rewrite(&ast, &matcher, &mut ());

Manual construction (rarely needed):

let mut matcher = SimplifiedPatternMatcher::<()>::new();
matcher.add(
    &[OpKey::Binary(BinaryOp::Add)],
    |uop, _ctx| {
        let Op::Binary(BinaryOp::Add, left, right) = uop.op() else {
            return RewriteResult::NoMatch;
        };
        if is_zero(right) { RewriteResult::Rewritten(left.clone()) }
        else { RewriteResult::NoMatch }
    }
);

Implementations

impl<C> SimplifiedPatternMatcher<C>

pub fn new() -> Self

Create a new empty pattern matcher.

pub fn add<F>(&mut self, keys: &[OpKey], closure: F)

where F: Fn(&Arc<UOp>, &mut C) -> RewriteResult + Send + Sync + 'static,

Add pattern for specific OpKey(s).

If keys is empty, the pattern is treated as a wildcard and will be tried for every UOp after all indexed patterns have been tried.

pub fn add_wildcard<F>(&mut self, closure: F)

where F: Fn(&Arc<UOp>, &mut C) -> RewriteResult + Send + Sync + 'static,

Add wildcard pattern (matches any op).

Wildcard patterns are tried after all indexed patterns have been tried.

pub fn len(&self) -> usize

Number of registered patterns.

pub fn is_empty(&self) -> bool

Check if no patterns are registered.

pub fn wildcard_count(&self) -> usize

Number of wildcard patterns (tried for every op).

pub fn indexed_count(&self) -> usize

Number of indexed buckets (unique OpKeys with patterns).

pub fn rewrite(&self, uop: &Arc<UOp>, ctx: &mut C) -> RewriteResult

Attempt to rewrite a UOp using registered patterns.

This is an inherent method that provides the same functionality as Matcher::rewrite() without requiring the trait to be in scope.

Tracing

Enable debug-level tracing to see pattern matching activity:

RUST_LOG=morok_ir::pattern=debug cargo run

impl SimplifiedPatternMatcher<()>

pub fn with_context<D: 'static + Send + Sync>( &self, ) -> SimplifiedPatternMatcher<D>

Lift a context-free matcher into any context type.

Since () patterns ignore the context parameter, they can safely run under any D. Each closure is re-wrapped to discard &mut D and pass &mut () to the original. This enables combining context-free matchers with context-dependent ones via +:

let mega = symbolic().with_context::<PcontigConfig>()
    + buffer_removal_with_pcontig(); // TypedPatternMatcher<PcontigConfig>

Trait Implementations

impl<C> Add<&SimplifiedPatternMatcher<C>> for SimplifiedPatternMatcher<C>

type Output = SimplifiedPatternMatcher<C>

The resulting type after applying the + operator.

fn add(self, rhs: &SimplifiedPatternMatcher<C>) -> Self::Output

Performs the + operation.

impl<C> Add<SimplifiedPatternMatcher<C>> for &SimplifiedPatternMatcher<C>

type Output = SimplifiedPatternMatcher<C>

The resulting type after applying the + operator.

fn add(self, rhs: SimplifiedPatternMatcher<C>) -> Self::Output

Performs the + operation.

impl<C> Add for &SimplifiedPatternMatcher<C>

type Output = SimplifiedPatternMatcher<C>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<C> Add for SimplifiedPatternMatcher<C>

fn add(self, rhs: Self) -> Self::Output

Combine two matchers. Patterns from rhs are appended.

type Output = SimplifiedPatternMatcher<C>

The resulting type after applying the + operator.

impl<C> Clone for SimplifiedPatternMatcher<C>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C> Default for SimplifiedPatternMatcher<C>

fn default() -> Self

Returns the “default value” for a type.

impl<C> Matcher<C> for SimplifiedPatternMatcher<C>

fn rewrite(&self, uop: &Arc<UOp>, ctx: &mut C) -> RewriteResult

Attempt to rewrite a UOp using registered patterns.