Struct parry::Rev

pub struct Rev<T>(_);

Trait Implementations

impl<T> Not for Rev<T> where Rev<T>: Expression, Rev<T>::Element: Not

type Output = Not<Self>

fn not(self) -> Self::Output

impl<T> Neg for Rev<T> where Rev<T>: Expression, Rev<T>::Element: Neg

type Output = Neg<Self>

fn neg(self) -> Self::Output

impl<T, Rhs> Add<Rhs> for Rev<T> where Rev<T>: Expression, Rhs: Expression, Rev<T>::Element: Add<Rhs::Element>

type Output = Add<Self, Rhs>

fn add(self, other: Rhs) -> Self::Output

impl<T, Rhs> Sub<Rhs> for Rev<T> where Rev<T>: Expression, Rhs: Expression, Rev<T>::Element: Sub<Rhs::Element>

type Output = Sub<Self, Rhs>

fn sub(self, other: Rhs) -> Self::Output

impl<T, Rhs> Mul<Rhs> for Rev<T> where Rev<T>: Expression, Rhs: Expression, Rev<T>::Element: Mul<Rhs::Element>

type Output = Mul<Self, Rhs>

fn mul(self, other: Rhs) -> Self::Output

impl<T, Rhs> Div<Rhs> for Rev<T> where Rev<T>: Expression, Rhs: Expression, Rev<T>::Element: Div<Rhs::Element>

type Output = Div<Self, Rhs>

fn div(self, other: Rhs) -> Self::Output

impl<T, Rhs> BitOr<Rhs> for Rev<T> where Rev<T>: Expression, Rhs: Expression, Rev<T>::Element: BitOr<Rhs::Element>

type Output = BitOr<Self, Rhs>

fn bitor(self, other: Rhs) -> Self::Output

impl<T, Rhs> BitAnd<Rhs> for Rev<T> where Rev<T>: Expression, Rhs: Expression, Rev<T>::Element: BitAnd<Rhs::Element>

type Output = BitAnd<Self, Rhs>

fn bitand(self, other: Rhs) -> Self::Output

impl<T, Rhs> BitXor<Rhs> for Rev<T> where Rev<T>: Expression, Rhs: Expression, Rev<T>::Element: BitXor<Rhs::Element>

type Output = BitXor<Self, Rhs>

fn bitxor(self, other: Rhs) -> Self::Output

impl<T: Expression> Expression for Rev<T>

type Element = T::Element

type Values = Rev<T::Values>

type Rev = T

fn length(&self) -> Length

fn values(self) -> Self::Values

fn split(self, round_up: bool) -> (Self, Self)

fn rev(self) -> T

fn sum<T>(self) -> Self::Element where Self: Sized + Expression<Element=T>, T: Zero + Add<T, Output=T>

fn max(self) -> Max::Output where Self: Sized, Max: Reduce<Self::Element>

fn min(self) -> Min::Output where Self: Sized, Min: Reduce<Self::Element>

fn zip<E2: Expression>(self, e: E2) -> Zip<Self, E2> where Self: Sized

fn map<O, F: FnMut(Self::Element) -> O>(self, f: F) -> Map<Self, F> where Self: Sized

fn switch<T, E>(self, then: T, else_: E) -> Switch<Self, T, E> where Self: Sized + Expression<Element=bool>, T: Expression, E: Expression<Element=T::Element>

fn eq<E>(self, other: E) -> Eq<Self, E> where Self: Sized, E: Expression, Self::Element: PartialEq<E::Element>

fn ne<E>(self, other: E) -> Ne<Self, E> where Self: Sized, E: Expression, Self::Element: PartialEq<E::Element>

fn lt<E>(self, other: E) -> Lt<Self, E> where Self: Sized, E: Expression, Self::Element: PartialOrd<E::Element>

fn le<E>(self, other: E) -> Le<Self, E> where Self: Sized, E: Expression, Self::Element: PartialOrd<E::Element>

fn gt<E>(self, other: E) -> Gt<Self, E> where Self: Sized, E: Expression, Self::Element: PartialOrd<E::Element>

fn ge<E>(self, other: E) -> Ge<Self, E> where Self: Sized, E: Expression, Self::Element: PartialOrd<E::Element>

Derived Implementations

impl<T: Clone> Clone for Rev<T>

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

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

impl<T: Copy> Copy for Rev<T>