Enum rational_deduction::ExprRef

pub enum ExprRef<'e, E> where
    E: 'e + Expression,  {
    Atom(&'e <E as Expression>::Atom),
    Group(<<E as Expression>::Group as IntoIteratorGen<E>>::IterGen),
}

Internal Reference to an Expression Type

Variants

Atom(&'e <E as Expression>::Atom)

Reference to an atomic expression

Group(<<E as Expression>::Group as IntoIteratorGen<E>>::IterGen)

Grouped expression IteratorGen

Implementations

impl<'e, E> ExprRef<'e, E> where
    E: Expression, 

#[must_use]pub fn is_atom(&self) -> bool

Checks if the ExprRef is atomic.

#[must_use]pub fn is_group(&self) -> bool

Checks if the ExprRef is a grouped expression IteratorGen.

#[must_use]pub fn atom(self) -> Option<&'e <E as Expression>::Atom>

Converts from an ExprRef<E> to an Option<&E::Atom>.

#[must_use]pub fn group(
    self
) -> Option<<<E as Expression>::Group as IntoIteratorGen<E>>::IterGen>

Converts from an ExprRef<E> to an Option<E::Group::IterGen>.

pub fn unwrap_atom(self) -> &'e <E as Expression>::Atom

Returns the contained Atom value, consuming the self value.

Panics

Panics if the self value is a Group.

pub fn unwrap_group(
    self
) -> <<E as Expression>::Group as IntoIteratorGen<E>>::IterGen

Returns the contained Group value, consuming the self value.

Panics

Panics if the self value is an Atom.

pub fn is_subexpression<R>(&self, other: &ExprRef<'r, R>) -> bool where
    R: Expression,
    <E as Expression>::Atom: PartialEq<<R as Expression>::Atom>, 

Checks if an Expression is a sub-tree of another Expression using PartialEq on their Atoms.

pub fn map_ref<O, F>(&self, f: F) -> O where
    F: FnMut(&<E as Expression>::Atom) -> <O as Expression>::Atom,
    O: Expression,
    <O as Expression>::Group: FromIterator<O>, 

Extends a function on &Atoms to a function on &Expressions.

pub fn substitute_ref<F>(&self, f: F) -> E where
    F: FnMut(&<E as Expression>::Atom) -> E,
    <E as Expression>::Group: FromIterator<E>, 

Substitutes an Expression into each Atom of &self.

pub fn eq_groups<R>(
    lhs: &<<E as Expression>::Group as IntoIteratorGen<E>>::IterGen,
    rhs: &<<R as Expression>::Group as IntoIteratorGen<R>>::IterGen
) -> bool where
    R: Expression,
    <E as Expression>::Atom: PartialEq<<R as Expression>::Atom>, 

Checks if two groups are equal.

Trait Implementations

impl<'e, E> From<ExprRef<'e, E>> for Expr<E> where
    E: Expression,
    <E as Expression>::Atom: Clone,
    <E as Expression>::Group: FromIterator<E>, 

#[must_use]pub fn from(expr_ref: ExprRef<'e, E>) -> Expr<E>

Performs the conversion.

impl<'l, 'r, L, R> PartialEq<ExprRef<'r, R>> for ExprRef<'l, L> where
    R: Expression,
    L: Expression,
    <L as Expression>::Atom: PartialEq<<R as Expression>::Atom>, 

pub fn eq(&self, other: &ExprRef<'r, R>) -> bool

Checks if two Expressions are equal using PartialEq on their Atoms.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.