Trait Matchable 

pub trait Matchable {
    // Required methods
    fn matches(&self, pattern: &Pattern) -> Option<PatternMatches>;
    fn replace(&self, pattern: &Pattern, replacement: &Pattern) -> Expression;
}

Trait for types that support pattern matching

Required Methods

fn matches(&self, pattern: &Pattern) -> Option<PatternMatches>

Match this expression against a pattern

Returns bindings for wildcard names if the match succeeds, or None if the pattern doesn’t match.

Arguments

• pattern - The pattern to match against

Examples

use mathhook_core::prelude::*;
use mathhook_core::pattern::{Pattern, Matchable};

let x = symbol!(x);
let expr = Expression::add(vec![
    Expression::mul(vec![Expression::integer(2), Expression::symbol(x.clone())]),
    Expression::integer(1)
]);

// Pattern: a*x + b
let pattern = Pattern::Add(vec![
    Pattern::Mul(vec![
        Pattern::wildcard("a"),
        Pattern::Exact(Expression::symbol(x.clone()))
    ]),
    Pattern::wildcard("b")
]);

let matches = expr.matches(&pattern);
assert!(matches.is_some());

if let Some(bindings) = matches {
    assert_eq!(bindings.get("a"), Some(&Expression::integer(2)));
    assert_eq!(bindings.get("b"), Some(&Expression::integer(1)));
}

fn replace(&self, pattern: &Pattern, replacement: &Pattern) -> Expression

Replace all occurrences of a pattern with a replacement expression

Uses pattern matching to find matches and applies the replacement, substituting wildcards with their matched values.

Arguments

• pattern - The pattern to match
• replacement - The replacement pattern (can contain wildcards from match)

Examples

use mathhook_core::prelude::*;
use mathhook_core::pattern::{Pattern, Matchable};

let x = symbol!(x);
// sin(x)^2 + cos(x)^2
let expr = Expression::add(vec![
    Expression::pow(
        Expression::function("sin".to_string(), vec![Expression::symbol(x.clone())]),
        Expression::integer(2)
    ),
    Expression::pow(
        Expression::function("cos".to_string(), vec![Expression::symbol(x.clone())]),
        Expression::integer(2)
    )
]);

// Pattern: sin(a)^2 + cos(a)^2
let pattern = Pattern::Add(vec![
    Pattern::Pow(
        Box::new(Pattern::Function {
            name: "sin".to_string(),
            args: vec![Pattern::wildcard("a")]
        }),
        Box::new(Pattern::Exact(Expression::integer(2)))
    ),
    Pattern::Pow(
        Box::new(Pattern::Function {
            name: "cos".to_string(),
            args: vec![Pattern::wildcard("a")]
        }),
        Box::new(Pattern::Exact(Expression::integer(2)))
    )
]);

// Replacement: 1
let replacement = Pattern::Exact(Expression::integer(1));

let result = expr.replace(&pattern, &replacement);
assert_eq!(result, Expression::integer(1));

Implementors

impl Matchable for Expression