Struct xpr::Xpr

pub struct Xpr<T>(_);

An expression. Xpr together with the Fold trait are at the heart of this crate.

The nested type is a specific struct representing the operation, e.g. ops::Add.

Xpr instances should be instantiated via the Xpr::new method, which creates Xpr<ops::Term> leaf expressions. The other variants are constructed from them by applying operations to the leaf expressions.

use xpr::*;
let x = Xpr::new(5);
let y = Xpr::new(1);
let z = x * y;
//type of z is xpr::Xpr<xpr::ops::Mul<xpr::Xpr<xpr::ops::Term<{integer}>>, xpr::Xpr<xpr::ops::Term<{integer}>>>>

Implementations

impl<T> Xpr<Term<T>>

pub const fn new(t: T) -> Self

creates a new leaf expression.

impl<U> Xpr<U>

pub fn eval<T>(&self) -> <Self as Foldable<Evaluator<T>>>::Output where
    T: Clone,
    U: Foldable<Evaluator<T>>,
    Evaluator<T>: Fold<U> + Fold<Self>, 

evaluates the expression by unwrapping all terminals and applying the operations in the expression. It is synactic sugar for folding the expression with [Evaluator].

Trait Implementations

impl<'a, L, R> Add<&'a R> for Xpr<L> where
    R: Expression, 

type Output = Xpr<Add<Self, Xpr<Term<&'a R>>>>

The resulting type after applying the + operator.

fn add(self, other: &'a R) -> Self::Output

Performs the + operation.

impl<L, R> Add<Xpr<R>> for Xpr<L>

type Output = Xpr<Add<Xpr<L>, Xpr<R>>>

The resulting type after applying the + operator.

fn add(self, other: Xpr<R>) -> Self::Output

Performs the + operation.

impl<'a, L, R> BitAnd<&'a R> for Xpr<L> where
    R: Expression, 

type Output = Xpr<BitAnd<Self, Xpr<Term<&'a R>>>>

The resulting type after applying the & operator.

fn bitand(self, other: &'a R) -> Self::Output

Performs the & operation.

impl<L, R> BitAnd<Xpr<R>> for Xpr<L>

type Output = Xpr<BitAnd<Xpr<L>, Xpr<R>>>

The resulting type after applying the & operator.

fn bitand(self, other: Xpr<R>) -> Self::Output

Performs the & operation.

impl<'a, L, R> BitOr<&'a R> for Xpr<L> where
    R: Expression, 

type Output = Xpr<BitOr<Self, Xpr<Term<&'a R>>>>

The resulting type after applying the | operator.

fn bitor(self, other: &'a R) -> Self::Output

Performs the | operation.

impl<L, R> BitOr<Xpr<R>> for Xpr<L>

type Output = Xpr<BitOr<Xpr<L>, Xpr<R>>>

The resulting type after applying the | operator.

fn bitor(self, other: Xpr<R>) -> Self::Output

Performs the | operation.

impl<'a, L, R> BitXor<&'a R> for Xpr<L> where
    R: Expression, 

type Output = Xpr<BitXor<Self, Xpr<Term<&'a R>>>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a R) -> Self::Output

Performs the ^ operation.

impl<L, R> BitXor<Xpr<R>> for Xpr<L>

type Output = Xpr<BitXor<Xpr<L>, Xpr<R>>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Xpr<R>) -> Self::Output

Performs the ^ operation.

impl<T: Clone> Clone for Xpr<T>

fn clone(&self) -> Xpr<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Xpr<T>

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

Formats the value using the given formatter.

impl<'a, L, R> Div<&'a R> for Xpr<L> where
    R: Expression, 

type Output = Xpr<Div<Self, Xpr<Term<&'a R>>>>

The resulting type after applying the / operator.

fn div(self, other: &'a R) -> Self::Output

Performs the / operation.

impl<L, R> Div<Xpr<R>> for Xpr<L>

type Output = Xpr<Div<Xpr<L>, Xpr<R>>>

The resulting type after applying the / operator.

fn div(self, other: Xpr<R>) -> Self::Output

Performs the / operation.

impl<T, U> Fold<Xpr<T>> for U where
    U: Fold<T>,
    T: Foldable<Self>, 

type Output = <T as Foldable<Self>>::Output

The output of Fold::fold, Self will replace all instances of T in an expression by values of this type.

fn fold(&mut self, Xpr: &Xpr<T>) -> <T as Foldable<Self>>::Output

perform the replacement

impl<'a, L, R> Mul<&'a R> for Xpr<L> where
    R: Expression, 

type Output = Xpr<Mul<Self, Xpr<Term<&'a R>>>>

The resulting type after applying the * operator.

fn mul(self, other: &'a R) -> Self::Output

Performs the * operation.

impl<L, R> Mul<Xpr<R>> for Xpr<L>

type Output = Xpr<Mul<Xpr<L>, Xpr<R>>>

The resulting type after applying the * operator.

fn mul(self, other: Xpr<R>) -> Self::Output

Performs the * operation.

impl<T> Neg for Xpr<T>

type Output = Xpr<Neg<Xpr<T>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> Not for Xpr<T>

type Output = Xpr<Not<Xpr<T>>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'a, L, R> Rem<&'a R> for Xpr<L> where
    R: Expression, 

type Output = Xpr<Rem<Self, Xpr<Term<&'a R>>>>

The resulting type after applying the % operator.

fn rem(self, other: &'a R) -> Self::Output

Performs the % operation.

impl<L, R> Rem<Xpr<R>> for Xpr<L>

type Output = Xpr<Rem<Xpr<L>, Xpr<R>>>

The resulting type after applying the % operator.

fn rem(self, other: Xpr<R>) -> Self::Output

Performs the % operation.

impl<'a, L, R> Shl<&'a R> for Xpr<L> where
    R: Expression, 

type Output = Xpr<Shl<Self, Xpr<Term<&'a R>>>>

The resulting type after applying the << operator.

fn shl(self, other: &'a R) -> Self::Output

Performs the << operation.

impl<L, R> Shl<Xpr<R>> for Xpr<L>

type Output = Xpr<Shl<Xpr<L>, Xpr<R>>>

The resulting type after applying the << operator.

fn shl(self, other: Xpr<R>) -> Self::Output

Performs the << operation.

impl<'a, L, R> Shr<&'a R> for Xpr<L> where
    R: Expression, 

type Output = Xpr<Shr<Self, Xpr<Term<&'a R>>>>

The resulting type after applying the >> operator.

fn shr(self, other: &'a R) -> Self::Output

Performs the >> operation.

impl<L, R> Shr<Xpr<R>> for Xpr<L>

type Output = Xpr<Shr<Xpr<L>, Xpr<R>>>

The resulting type after applying the >> operator.

fn shr(self, other: Xpr<R>) -> Self::Output

Performs the >> operation.

impl<'a, L, R> Sub<&'a R> for Xpr<L> where
    R: Expression, 

type Output = Xpr<Sub<Self, Xpr<Term<&'a R>>>>

The resulting type after applying the - operator.

fn sub(self, other: &'a R) -> Self::Output

Performs the - operation.

impl<L, R> Sub<Xpr<R>> for Xpr<L>

type Output = Xpr<Sub<Xpr<L>, Xpr<R>>>

The resulting type after applying the - operator.

fn sub(self, other: Xpr<R>) -> Self::Output

Performs the - operation.

impl<T: Copy> Copy for Xpr<T>