Struct PatternRule 

pub struct PatternRule {
    pub lhs: Pattern,
    pub rhs: ExprId,
    /* private fields */
}

A rewrite rule specified as a (lhs pattern, rhs template) pair.

When the rule fires, all wildcards bound by matching lhs against the current expression are substituted into rhs.

Wildcard convention

Any Symbol whose name starts with a lower-case letter is a wildcard.

Example

let pool = ExprPool::new();
let a = pool.symbol("a", Domain::Real);  // wildcard
let b = pool.symbol("b", Domain::Real);  // wildcard
// Rule: a*b + a*c → a*(b+c)  (factoring)
// lhs pattern: a*b  (simplified, as a*b is the structure)
// Here we demonstrate a simpler identity: a + a → 2*a
let lhs = pool.add(vec![a, a]);
let two_a = pool.mul(vec![pool.integer(2_i32), a]);
let rule = PatternRule::new(Pattern::from_expr(lhs), two_a);
let x = pool.symbol("x", Domain::Real);
let expr = pool.add(vec![x, x]);
let r = simplify_with(expr, &pool, &[Box::new(rule)], SimplifyConfig::default());
// x + x → 2*x

Fields

lhs: Pattern

rhs: ExprId

Implementations

impl PatternRule

pub fn new(lhs: Pattern, rhs: ExprId) -> Self

pub fn named(lhs: Pattern, rhs: ExprId, name: &'static str) -> Self

Trait Implementations

impl RewriteRule for PatternRule

fn name(&self) -> &'static str

fn apply( &self, expr: ExprId, pool: &ExprPool, ) -> Option<(ExprId, DerivationLog)>

Try to apply the rule to expr. Returns None if the rule does not match.