Struct parry::Map [−] [src]

pub struct Map<X, F>(_, _);

Trait Implementations

`impl<X, F> Not for Map<X, F> where Map<X, F>: Expression, Map<X, F>::Element: Not`

`type Output = Not<Self>`

`fn not(self) -> Self::Output`

`impl<X, F> Neg for Map<X, F> where Map<X, F>: Expression, Map<X, F>::Element: Neg`

`type Output = Neg<Self>`

`fn neg(self) -> Self::Output`

`impl<X, F, Rhs> Add<Rhs> for Map<X, F> where Map<X, F>: Expression, Rhs: Expression, Map<X, F>::Element: Add<Rhs::Element>`

`type Output = Add<Self, Rhs>`

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

`impl<X, F, Rhs> Sub<Rhs> for Map<X, F> where Map<X, F>: Expression, Rhs: Expression, Map<X, F>::Element: Sub<Rhs::Element>`

`type Output = Sub<Self, Rhs>`

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

`impl<X, F, Rhs> Mul<Rhs> for Map<X, F> where Map<X, F>: Expression, Rhs: Expression, Map<X, F>::Element: Mul<Rhs::Element>`

`type Output = Mul<Self, Rhs>`

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

`impl<X, F, Rhs> Div<Rhs> for Map<X, F> where Map<X, F>: Expression, Rhs: Expression, Map<X, F>::Element: Div<Rhs::Element>`

`type Output = Div<Self, Rhs>`

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

`impl<X, F, Rhs> BitOr<Rhs> for Map<X, F> where Map<X, F>: Expression, Rhs: Expression, Map<X, F>::Element: BitOr<Rhs::Element>`

`type Output = BitOr<Self, Rhs>`

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

`impl<X, F, Rhs> BitAnd<Rhs> for Map<X, F> where Map<X, F>: Expression, Rhs: Expression, Map<X, F>::Element: BitAnd<Rhs::Element>`

`type Output = BitAnd<Self, Rhs>`

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

`impl<X, F, Rhs> BitXor<Rhs> for Map<X, F> where Map<X, F>: Expression, Rhs: Expression, Map<X, F>::Element: BitXor<Rhs::Element>`

`type Output = BitXor<Self, Rhs>`

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

`impl<X: Expression, O: Send, F: Clone + FnMut(X::Element) -> O + Send> Expression for Map<X, F>`

`type Element = O`

`type Values = Map<X::Values, F>`

`type Rev = Map<X::Rev, F>`

`fn length(&self) -> Length`

`fn values(self) -> Self::Values`

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

`fn rev(self) -> Self::Rev`

`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<X: Clone, F: Clone> Clone for Map<X, F>`

`fn clone(&self) -> Map<X, F>`

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

`impl<X: Copy, F: Copy> Copy for Map<X, F>`