Struct parry::Zip [−] [src]

pub struct Zip<X, Y>(_, _);

Trait Implementations

`impl<X, Y> Not for Zip<X, Y> where Zip<X, Y>: Expression, Zip<X, Y>::Element: Not`

`type Output = Not<Self>`

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

`impl<X, Y> Neg for Zip<X, Y> where Zip<X, Y>: Expression, Zip<X, Y>::Element: Neg`

`type Output = Neg<Self>`

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

`impl<X, Y, Rhs> Add<Rhs> for Zip<X, Y> where Zip<X, Y>: Expression, Rhs: Expression, Zip<X, Y>::Element: Add<Rhs::Element>`

`type Output = Add<Self, Rhs>`

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

`impl<X, Y, Rhs> Sub<Rhs> for Zip<X, Y> where Zip<X, Y>: Expression, Rhs: Expression, Zip<X, Y>::Element: Sub<Rhs::Element>`

`type Output = Sub<Self, Rhs>`

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

`impl<X, Y, Rhs> Mul<Rhs> for Zip<X, Y> where Zip<X, Y>: Expression, Rhs: Expression, Zip<X, Y>::Element: Mul<Rhs::Element>`

`type Output = Mul<Self, Rhs>`

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

`impl<X, Y, Rhs> Div<Rhs> for Zip<X, Y> where Zip<X, Y>: Expression, Rhs: Expression, Zip<X, Y>::Element: Div<Rhs::Element>`

`type Output = Div<Self, Rhs>`

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

`impl<X, Y, Rhs> BitOr<Rhs> for Zip<X, Y> where Zip<X, Y>: Expression, Rhs: Expression, Zip<X, Y>::Element: BitOr<Rhs::Element>`

`type Output = BitOr<Self, Rhs>`

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

`impl<X, Y, Rhs> BitAnd<Rhs> for Zip<X, Y> where Zip<X, Y>: Expression, Rhs: Expression, Zip<X, Y>::Element: BitAnd<Rhs::Element>`

`type Output = BitAnd<Self, Rhs>`

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

`impl<X, Y, Rhs> BitXor<Rhs> for Zip<X, Y> where Zip<X, Y>: Expression, Rhs: Expression, Zip<X, Y>::Element: BitXor<Rhs::Element>`

`type Output = BitXor<Self, Rhs>`

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

`impl<X: Expression, Y: Expression> Expression for Zip<X, Y>`

`type Element = (X::Element, Y::Element)`

`type Values = Binary<Tuple, X::Values, Y::Values>`

`type Rev = Zip<X::Rev, Y::Rev>`

`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, Y: Clone> Clone for Zip<X, Y>`

`fn clone(&self) -> Zip<X, Y>`

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

`impl<X: Copy, Y: Copy> Copy for Zip<X, Y>`