Enum Pattern 

pub enum Pattern {
    Var(String),
    Constant(f64),
    Pred {
        name: String,
        args: Vec<Pattern>,
    },
    And(Box<Pattern>, Box<Pattern>),
    Or(Box<Pattern>, Box<Pattern>),
    Not(Box<Pattern>),
    Imply(Box<Pattern>, Box<Pattern>),
    Any,
    Add(Box<Pattern>, Box<Pattern>),
    Sub(Box<Pattern>, Box<Pattern>),
    Mul(Box<Pattern>, Box<Pattern>),
    Div(Box<Pattern>, Box<Pattern>),
    Pow(Box<Pattern>, Box<Pattern>),
    Neg(Box<Pattern>),
    Exp(Box<Pattern>),
    Log(Box<Pattern>),
    Sin(Box<Pattern>),
    Cos(Box<Pattern>),
    Tan(Box<Pattern>),
}

A pattern that can match against expressions.

Variants

Var(String)

Match any expression and bind it to a variable

Constant(f64)

Match a specific constant value

Pred

Match a predicate with a specific name

Fields

name: String

args: Vec<Pattern>

And(Box<Pattern>, Box<Pattern>)

Match an AND expression

Or(Box<Pattern>, Box<Pattern>)

Match an OR expression

Not(Box<Pattern>)

Match a NOT expression

Imply(Box<Pattern>, Box<Pattern>)

Match an implication

Any

Match any expression (wildcard)

Add(Box<Pattern>, Box<Pattern>)

Match an addition

Sub(Box<Pattern>, Box<Pattern>)

Match a subtraction

Mul(Box<Pattern>, Box<Pattern>)

Match a multiplication

Div(Box<Pattern>, Box<Pattern>)

Match a division

Pow(Box<Pattern>, Box<Pattern>)

Match a power

Neg(Box<Pattern>)

Match negation (encoded as Sub(0, x) in TLExpr)

Exp(Box<Pattern>)

Match an exponential

Log(Box<Pattern>)

Match a logarithm

Sin(Box<Pattern>)

Match a sine

Cos(Box<Pattern>)

Match a cosine

Tan(Box<Pattern>)

Match a tangent

Implementations

impl Pattern

pub fn var(name: impl Into<String>) -> Self

Create a variable pattern.

pub fn constant(value: f64) -> Self

Create a constant pattern.

pub fn any() -> Self

Create a wildcard pattern.

pub fn pred(name: impl Into<String>, args: Vec<Pattern>) -> Self

Create a predicate pattern.

pub fn and(left: Pattern, right: Pattern) -> Self

Create an AND pattern.

pub fn or(left: Pattern, right: Pattern) -> Self

Create an OR pattern.

pub fn negation(pattern: Pattern) -> Self

Create a NOT pattern.

pub fn imply(left: Pattern, right: Pattern) -> Self

Create an implication pattern.

pub fn add(left: Pattern, right: Pattern) -> Self

Create an addition pattern.

pub fn sub(left: Pattern, right: Pattern) -> Self

Create a subtraction pattern.

pub fn mul(left: Pattern, right: Pattern) -> Self

Create a multiplication pattern.

pub fn div(left: Pattern, right: Pattern) -> Self

Create a division pattern.

pub fn pow(left: Pattern, right: Pattern) -> Self

Create a power pattern.

pub fn neg(inner: Pattern) -> Self

Create a negation pattern (matches Sub(0, x)).

pub fn exp(inner: Pattern) -> Self

Create an exponential pattern.

pub fn log(inner: Pattern) -> Self

Create a logarithm pattern.

pub fn sin(inner: Pattern) -> Self

Create a sine pattern.

pub fn cos(inner: Pattern) -> Self

Create a cosine pattern.

pub fn tan(inner: Pattern) -> Self

Create a tangent pattern.

pub fn matches(&self, expr: &TLExpr) -> Option<HashMap<String, TLExpr>>

Try to match this pattern against an expression, returning bindings if successful.

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Pattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Pattern

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

Formats the value using the given formatter.

impl PartialEq for Pattern

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Pattern