Trait Pattern 

pub trait Pattern<O: Operand> {
    type Bindings;

    // Required method
    fn try_match(&self, operand: &O) -> Option<Self::Bindings>;

    // Provided methods
    fn rewrite<F>(self, rewrite: F) -> impl Rule<O>
       where Self: Sized + Send + Sync + 'static,
             O: 'static,
             F: Fn(Self::Bindings, &Stats<'_>) -> Option<O> + Send + Sync + 'static { ... }
    fn guard<G>(self, guard: G) -> GuardedPattern<Self, G>
       where Self: Sized,
             G: Fn(&Stats<'_>) -> bool { ... }
    fn or<Q>(self, other: Q) -> impl Pattern<O, Bindings = Self::Bindings>
       where Self: Sized,
             Q: Pattern<O, Bindings = Self::Bindings> { ... }
}

Required Associated Types

type Bindings

Required Methods

fn try_match(&self, operand: &O) -> Option<Self::Bindings>

Provided Methods

fn rewrite<F>(self, rewrite: F) -> impl Rule<O>

where Self: Sized + Send + Sync + 'static, O: 'static, F: Fn(Self::Bindings, &Stats<'_>) -> Option<O> + Send + Sync + 'static,

fn guard<G>(self, guard: G) -> GuardedPattern<Self, G>

where Self: Sized, G: Fn(&Stats<'_>) -> bool,

fn or<Q>(self, other: Q) -> impl Pattern<O, Bindings = Self::Bindings>

where Self: Sized, Q: Pattern<O, Bindings = Self::Bindings>,

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<C, P, B> Pattern<<C as OptimizePlan>::Output> for Matching<C, P>

where C: PlanNode + MatchInputs + OptimizePlan, P: for<'a> MatchAgainst<C::Inputs<'a>, Bindings = B>,

type Bindings = B

impl<O: Operand, P: Pattern<O>> Pattern<O> for NotPattern<P>

type Bindings = ()

impl<O: Operand> Pattern<O> for Capture

type Bindings = O

impl<O: Operand> Pattern<O> for Wildcard

type Bindings = ()