Enum egg::Pattern

#[non_exhaustive]
pub enum Pattern<L> {
    // some variants omitted
}

A pattern that can function as either a Searcher or Applier.

A Pattern is essentially a for-all quantified expression with QuestionMarkNames as the variables (in the logical sense).

When creating a Rewrite, the most common thing to use as either the left hand side (the Searcher) or the right hand side (the Applier) is a Pattern.

As a Searcher, a Pattern does the intuitive thing. Here is a somewhat verbose formal-ish statement: Searching for a pattern in an egraph yields substitutions (a.k.a WildMaps) s such that, for any s'—where instead of mapping a variables to an eclass as s does, s' maps a variable to an arbitrary expression represented by that eclass—p[s'] (the pattern under substitution s') is also represented by the egraph.

As an Applier, a Pattern performs the given substitution and adds the result to the EGraph.

Importantly, Pattern implements FromStr if the Language does. This is probably how you'll create most Patterns.

use egg::*;
define_language! {
    enum Math {
        Num(i32),
        Add = "+",
    }
}

let mut egraph = EGraph::<Math, ()>::default();
let a11 = egraph.add_expr(&"(+ 1 1)".parse().unwrap());
let a22 = egraph.add_expr(&"(+ 2 2)".parse().unwrap());

// use QuestionMarkName syntax (leading question mark) to get a
// variable in the Pattern
let same_add: Pattern<Math> = "(+ ?a ?a)".parse().unwrap();

// This is the search method from the Searcher trait
let matches = same_add.search(&egraph);
let matched_eclasses: Vec<Id> = matches.iter().map(|m| m.eclass).collect();
assert_eq!(matched_eclasses, vec![a11, a22]);

Trait Implementations

impl<L: Language, M: Metadata<L>> Applier<L, M> for Pattern<L>

fn apply_one(
    &self,
    egraph: &mut EGraph<L, M>,
    _: Id,
    mapping: &WildMap
) -> Vec<Id>

Apply a single substitition.

fn apply_matches(
    &self,
    egraph: &mut EGraph<L, M>,
    matches: &[SearchMatches]
) -> Vec<Id>

Apply many substititions.

impl<L: Clone> Clone for Pattern<L>

fn clone(&self) -> Pattern<L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Debug> Debug for Pattern<L>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<L: Language> From<RecExpr<L>> for Pattern<L>

fn from(e: RecExpr<L>) -> Self

Performs the conversion.

impl<L: Language + FromStr> FromStr for Pattern<L>

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, ParseError>

Parses a string s to return a value of this type.

impl<L: PartialEq> PartialEq<Pattern<L>> for Pattern<L>

fn eq(&self, other: &Pattern<L>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Pattern<L>) -> bool

This method tests for !=.

impl<L, M> Searcher<L, M> for Pattern<L> where
    L: Language,
    M: Metadata<L>, 

fn search(&self, egraph: &EGraph<L, M>) -> Vec<SearchMatches>

Search the whole [EGraph], returning a list of all the [SearchMatches] where something was found. This just calls [search_eclass] on each eclass.

fn search_eclass(
    &self,
    egraph: &EGraph<L, M>,
    eclass: Id
) -> Option<SearchMatches>

Search one eclass, returning None if no matches can be found. This should not return a SearchMatches with no mappings.

impl<L> StructuralPartialEq for Pattern<L>

impl<L: Language> TryFrom<Pattern<L>> for RecExpr<L>

type Error = String

The type returned in the event of a conversion error.

fn try_from(pat: Pattern<L>) -> Result<RecExpr<L>, String>

Performs the conversion.