[][src]Enum sum::Sum32

pub enum Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> {
    A(A),
    B(B),
    C(C),
    D(D),
    E(E),
    F(F),
    G(G),
    H(H),
    I(I),
    J(J),
    K(K),
    L(L),
    M(M),
    N(N),
    O(O),
    P(P),
    Q(Q),
    R(R),
    S(S),
    T(T),
    U(U),
    V(V),
    W(W),
    X(X),
    Y(Y),
    Z(Z),
    Aa(Aa),
    Ab(Ab),
    Ac(Ac),
    Ad(Ad),
    Ae(Ae),
    Af(Af),
}

Variants

A(A)
B(B)
C(C)
D(D)
E(E)
F(F)
G(G)
H(H)
I(I)
J(J)
K(K)
L(L)
M(M)
N(N)
O(O)
P(P)
Q(Q)
R(R)
S(S)
T(T)
U(U)
V(V)
W(W)
X(X)
Y(Y)
Z(Z)
Aa(Aa)
Ab(Ab)
Ac(Ac)
Ad(Ad)
Ae(Ae)
Af(Af)

Implementations

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>[src]

pub fn is_a(&self) -> bool[src]

pub fn a(self) -> Option<A>[src]

pub fn is_b(&self) -> bool[src]

pub fn b(self) -> Option<B>[src]

pub fn is_c(&self) -> bool[src]

pub fn c(self) -> Option<C>[src]

pub fn is_d(&self) -> bool[src]

pub fn d(self) -> Option<D>[src]

pub fn is_e(&self) -> bool[src]

pub fn e(self) -> Option<E>[src]

pub fn is_f(&self) -> bool[src]

pub fn f(self) -> Option<F>[src]

pub fn is_g(&self) -> bool[src]

pub fn g(self) -> Option<G>[src]

pub fn is_h(&self) -> bool[src]

pub fn h(self) -> Option<H>[src]

pub fn is_i(&self) -> bool[src]

pub fn i(self) -> Option<I>[src]

pub fn is_j(&self) -> bool[src]

pub fn j(self) -> Option<J>[src]

pub fn is_k(&self) -> bool[src]

pub fn k(self) -> Option<K>[src]

pub fn is_l(&self) -> bool[src]

pub fn l(self) -> Option<L>[src]

pub fn is_m(&self) -> bool[src]

pub fn m(self) -> Option<M>[src]

pub fn is_n(&self) -> bool[src]

pub fn n(self) -> Option<N>[src]

pub fn is_o(&self) -> bool[src]

pub fn o(self) -> Option<O>[src]

pub fn is_p(&self) -> bool[src]

pub fn p(self) -> Option<P>[src]

pub fn is_q(&self) -> bool[src]

pub fn q(self) -> Option<Q>[src]

pub fn is_r(&self) -> bool[src]

pub fn r(self) -> Option<R>[src]

pub fn is_s(&self) -> bool[src]

pub fn s(self) -> Option<S>[src]

pub fn is_t(&self) -> bool[src]

pub fn t(self) -> Option<T>[src]

pub fn is_u(&self) -> bool[src]

pub fn u(self) -> Option<U>[src]

pub fn is_v(&self) -> bool[src]

pub fn v(self) -> Option<V>[src]

pub fn is_w(&self) -> bool[src]

pub fn w(self) -> Option<W>[src]

pub fn is_x(&self) -> bool[src]

pub fn x(self) -> Option<X>[src]

pub fn is_y(&self) -> bool[src]

pub fn y(self) -> Option<Y>[src]

pub fn is_z(&self) -> bool[src]

pub fn z(self) -> Option<Z>[src]

pub fn is_aa(&self) -> bool[src]

pub fn aa(self) -> Option<Aa>[src]

pub fn is_ab(&self) -> bool[src]

pub fn ab(self) -> Option<Ab>[src]

pub fn is_ac(&self) -> bool[src]

pub fn ac(self) -> Option<Ac>[src]

pub fn is_ad(&self) -> bool[src]

pub fn ad(self) -> Option<Ad>[src]

pub fn is_ae(&self) -> bool[src]

pub fn ae(self) -> Option<Ae>[src]

pub fn is_af(&self) -> bool[src]

pub fn af(self) -> Option<Af>[src]

pub fn as_ref(
    &self
) -> Sum32<&A, &B, &C, &D, &E, &F, &G, &H, &I, &J, &K, &L, &M, &N, &O, &P, &Q, &R, &S, &T, &U, &V, &W, &X, &Y, &Z, &Aa, &Ab, &Ac, &Ad, &Ae, &Af>

Important traits for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Iterator for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Iterator,
    B: Iterator<Item = A::Item>,
    C: Iterator<Item = A::Item>,
    D: Iterator<Item = A::Item>,
    E: Iterator<Item = A::Item>,
    F: Iterator<Item = A::Item>,
    G: Iterator<Item = A::Item>,
    H: Iterator<Item = A::Item>,
    I: Iterator<Item = A::Item>,
    J: Iterator<Item = A::Item>,
    K: Iterator<Item = A::Item>,
    L: Iterator<Item = A::Item>,
    M: Iterator<Item = A::Item>,
    N: Iterator<Item = A::Item>,
    O: Iterator<Item = A::Item>,
    P: Iterator<Item = A::Item>,
    Q: Iterator<Item = A::Item>,
    R: Iterator<Item = A::Item>,
    S: Iterator<Item = A::Item>,
    T: Iterator<Item = A::Item>,
    U: Iterator<Item = A::Item>,
    V: Iterator<Item = A::Item>,
    W: Iterator<Item = A::Item>,
    X: Iterator<Item = A::Item>,
    Y: Iterator<Item = A::Item>,
    Z: Iterator<Item = A::Item>,
    Aa: Iterator<Item = A::Item>,
    Ab: Iterator<Item = A::Item>,
    Ac: Iterator<Item = A::Item>,
    Ad: Iterator<Item = A::Item>,
    Ae: Iterator<Item = A::Item>,
    Af: Iterator<Item = A::Item>, 
type Item = A::Item;impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Future for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Future,
    B: Future<Output = A::Output>,
    C: Future<Output = A::Output>,
    D: Future<Output = A::Output>,
    E: Future<Output = A::Output>,
    F: Future<Output = A::Output>,
    G: Future<Output = A::Output>,
    H: Future<Output = A::Output>,
    I: Future<Output = A::Output>,
    J: Future<Output = A::Output>,
    K: Future<Output = A::Output>,
    L: Future<Output = A::Output>,
    M: Future<Output = A::Output>,
    N: Future<Output = A::Output>,
    O: Future<Output = A::Output>,
    P: Future<Output = A::Output>,
    Q: Future<Output = A::Output>,
    R: Future<Output = A::Output>,
    S: Future<Output = A::Output>,
    T: Future<Output = A::Output>,
    U: Future<Output = A::Output>,
    V: Future<Output = A::Output>,
    W: Future<Output = A::Output>,
    X: Future<Output = A::Output>,
    Y: Future<Output = A::Output>,
    Z: Future<Output = A::Output>,
    Aa: Future<Output = A::Output>,
    Ab: Future<Output = A::Output>,
    Ac: Future<Output = A::Output>,
    Ad: Future<Output = A::Output>,
    Ae: Future<Output = A::Output>,
    Af: Future<Output = A::Output>, 
type Output = A::Output;
[src]

pub fn as_mut(
    &mut self
) -> Sum32<&mut A, &mut B, &mut C, &mut D, &mut E, &mut F, &mut G, &mut H, &mut I, &mut J, &mut K, &mut L, &mut M, &mut N, &mut O, &mut P, &mut Q, &mut R, &mut S, &mut T, &mut U, &mut V, &mut W, &mut X, &mut Y, &mut Z, &mut Aa, &mut Ab, &mut Ac, &mut Ad, &mut Ae, &mut Af>

Important traits for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Iterator for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Iterator,
    B: Iterator<Item = A::Item>,
    C: Iterator<Item = A::Item>,
    D: Iterator<Item = A::Item>,
    E: Iterator<Item = A::Item>,
    F: Iterator<Item = A::Item>,
    G: Iterator<Item = A::Item>,
    H: Iterator<Item = A::Item>,
    I: Iterator<Item = A::Item>,
    J: Iterator<Item = A::Item>,
    K: Iterator<Item = A::Item>,
    L: Iterator<Item = A::Item>,
    M: Iterator<Item = A::Item>,
    N: Iterator<Item = A::Item>,
    O: Iterator<Item = A::Item>,
    P: Iterator<Item = A::Item>,
    Q: Iterator<Item = A::Item>,
    R: Iterator<Item = A::Item>,
    S: Iterator<Item = A::Item>,
    T: Iterator<Item = A::Item>,
    U: Iterator<Item = A::Item>,
    V: Iterator<Item = A::Item>,
    W: Iterator<Item = A::Item>,
    X: Iterator<Item = A::Item>,
    Y: Iterator<Item = A::Item>,
    Z: Iterator<Item = A::Item>,
    Aa: Iterator<Item = A::Item>,
    Ab: Iterator<Item = A::Item>,
    Ac: Iterator<Item = A::Item>,
    Ad: Iterator<Item = A::Item>,
    Ae: Iterator<Item = A::Item>,
    Af: Iterator<Item = A::Item>, 
type Item = A::Item;impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Future for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Future,
    B: Future<Output = A::Output>,
    C: Future<Output = A::Output>,
    D: Future<Output = A::Output>,
    E: Future<Output = A::Output>,
    F: Future<Output = A::Output>,
    G: Future<Output = A::Output>,
    H: Future<Output = A::Output>,
    I: Future<Output = A::Output>,
    J: Future<Output = A::Output>,
    K: Future<Output = A::Output>,
    L: Future<Output = A::Output>,
    M: Future<Output = A::Output>,
    N: Future<Output = A::Output>,
    O: Future<Output = A::Output>,
    P: Future<Output = A::Output>,
    Q: Future<Output = A::Output>,
    R: Future<Output = A::Output>,
    S: Future<Output = A::Output>,
    T: Future<Output = A::Output>,
    U: Future<Output = A::Output>,
    V: Future<Output = A::Output>,
    W: Future<Output = A::Output>,
    X: Future<Output = A::Output>,
    Y: Future<Output = A::Output>,
    Z: Future<Output = A::Output>,
    Aa: Future<Output = A::Output>,
    Ab: Future<Output = A::Output>,
    Ac: Future<Output = A::Output>,
    Ad: Future<Output = A::Output>,
    Ae: Future<Output = A::Output>,
    Af: Future<Output = A::Output>, 
type Output = A::Output;
[src]

pub fn as_pin_ref<'a>(
    self: Pin<&'a Self>
) -> Sum32<Pin<&'a A>, Pin<&'a B>, Pin<&'a C>, Pin<&'a D>, Pin<&'a E>, Pin<&'a F>, Pin<&'a G>, Pin<&'a H>, Pin<&'a I>, Pin<&'a J>, Pin<&'a K>, Pin<&'a L>, Pin<&'a M>, Pin<&'a N>, Pin<&'a O>, Pin<&'a P>, Pin<&'a Q>, Pin<&'a R>, Pin<&'a S>, Pin<&'a T>, Pin<&'a U>, Pin<&'a V>, Pin<&'a W>, Pin<&'a X>, Pin<&'a Y>, Pin<&'a Z>, Pin<&'a Aa>, Pin<&'a Ab>, Pin<&'a Ac>, Pin<&'a Ad>, Pin<&'a Ae>, Pin<&'a Af>>

Important traits for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Iterator for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Iterator,
    B: Iterator<Item = A::Item>,
    C: Iterator<Item = A::Item>,
    D: Iterator<Item = A::Item>,
    E: Iterator<Item = A::Item>,
    F: Iterator<Item = A::Item>,
    G: Iterator<Item = A::Item>,
    H: Iterator<Item = A::Item>,
    I: Iterator<Item = A::Item>,
    J: Iterator<Item = A::Item>,
    K: Iterator<Item = A::Item>,
    L: Iterator<Item = A::Item>,
    M: Iterator<Item = A::Item>,
    N: Iterator<Item = A::Item>,
    O: Iterator<Item = A::Item>,
    P: Iterator<Item = A::Item>,
    Q: Iterator<Item = A::Item>,
    R: Iterator<Item = A::Item>,
    S: Iterator<Item = A::Item>,
    T: Iterator<Item = A::Item>,
    U: Iterator<Item = A::Item>,
    V: Iterator<Item = A::Item>,
    W: Iterator<Item = A::Item>,
    X: Iterator<Item = A::Item>,
    Y: Iterator<Item = A::Item>,
    Z: Iterator<Item = A::Item>,
    Aa: Iterator<Item = A::Item>,
    Ab: Iterator<Item = A::Item>,
    Ac: Iterator<Item = A::Item>,
    Ad: Iterator<Item = A::Item>,
    Ae: Iterator<Item = A::Item>,
    Af: Iterator<Item = A::Item>, 
type Item = A::Item;impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Future for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Future,
    B: Future<Output = A::Output>,
    C: Future<Output = A::Output>,
    D: Future<Output = A::Output>,
    E: Future<Output = A::Output>,
    F: Future<Output = A::Output>,
    G: Future<Output = A::Output>,
    H: Future<Output = A::Output>,
    I: Future<Output = A::Output>,
    J: Future<Output = A::Output>,
    K: Future<Output = A::Output>,
    L: Future<Output = A::Output>,
    M: Future<Output = A::Output>,
    N: Future<Output = A::Output>,
    O: Future<Output = A::Output>,
    P: Future<Output = A::Output>,
    Q: Future<Output = A::Output>,
    R: Future<Output = A::Output>,
    S: Future<Output = A::Output>,
    T: Future<Output = A::Output>,
    U: Future<Output = A::Output>,
    V: Future<Output = A::Output>,
    W: Future<Output = A::Output>,
    X: Future<Output = A::Output>,
    Y: Future<Output = A::Output>,
    Z: Future<Output = A::Output>,
    Aa: Future<Output = A::Output>,
    Ab: Future<Output = A::Output>,
    Ac: Future<Output = A::Output>,
    Ad: Future<Output = A::Output>,
    Ae: Future<Output = A::Output>,
    Af: Future<Output = A::Output>, 
type Output = A::Output;
[src]

pub fn as_pin_mut<'a>(
    self: Pin<&'a mut Self>
) -> Sum32<Pin<&'a mut A>, Pin<&'a mut B>, Pin<&'a mut C>, Pin<&'a mut D>, Pin<&'a mut E>, Pin<&'a mut F>, Pin<&'a mut G>, Pin<&'a mut H>, Pin<&'a mut I>, Pin<&'a mut J>, Pin<&'a mut K>, Pin<&'a mut L>, Pin<&'a mut M>, Pin<&'a mut N>, Pin<&'a mut O>, Pin<&'a mut P>, Pin<&'a mut Q>, Pin<&'a mut R>, Pin<&'a mut S>, Pin<&'a mut T>, Pin<&'a mut U>, Pin<&'a mut V>, Pin<&'a mut W>, Pin<&'a mut X>, Pin<&'a mut Y>, Pin<&'a mut Z>, Pin<&'a mut Aa>, Pin<&'a mut Ab>, Pin<&'a mut Ac>, Pin<&'a mut Ad>, Pin<&'a mut Ae>, Pin<&'a mut Af>>

Important traits for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Iterator for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Iterator,
    B: Iterator<Item = A::Item>,
    C: Iterator<Item = A::Item>,
    D: Iterator<Item = A::Item>,
    E: Iterator<Item = A::Item>,
    F: Iterator<Item = A::Item>,
    G: Iterator<Item = A::Item>,
    H: Iterator<Item = A::Item>,
    I: Iterator<Item = A::Item>,
    J: Iterator<Item = A::Item>,
    K: Iterator<Item = A::Item>,
    L: Iterator<Item = A::Item>,
    M: Iterator<Item = A::Item>,
    N: Iterator<Item = A::Item>,
    O: Iterator<Item = A::Item>,
    P: Iterator<Item = A::Item>,
    Q: Iterator<Item = A::Item>,
    R: Iterator<Item = A::Item>,
    S: Iterator<Item = A::Item>,
    T: Iterator<Item = A::Item>,
    U: Iterator<Item = A::Item>,
    V: Iterator<Item = A::Item>,
    W: Iterator<Item = A::Item>,
    X: Iterator<Item = A::Item>,
    Y: Iterator<Item = A::Item>,
    Z: Iterator<Item = A::Item>,
    Aa: Iterator<Item = A::Item>,
    Ab: Iterator<Item = A::Item>,
    Ac: Iterator<Item = A::Item>,
    Ad: Iterator<Item = A::Item>,
    Ae: Iterator<Item = A::Item>,
    Af: Iterator<Item = A::Item>, 
type Item = A::Item;impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Future for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Future,
    B: Future<Output = A::Output>,
    C: Future<Output = A::Output>,
    D: Future<Output = A::Output>,
    E: Future<Output = A::Output>,
    F: Future<Output = A::Output>,
    G: Future<Output = A::Output>,
    H: Future<Output = A::Output>,
    I: Future<Output = A::Output>,
    J: Future<Output = A::Output>,
    K: Future<Output = A::Output>,
    L: Future<Output = A::Output>,
    M: Future<Output = A::Output>,
    N: Future<Output = A::Output>,
    O: Future<Output = A::Output>,
    P: Future<Output = A::Output>,
    Q: Future<Output = A::Output>,
    R: Future<Output = A::Output>,
    S: Future<Output = A::Output>,
    T: Future<Output = A::Output>,
    U: Future<Output = A::Output>,
    V: Future<Output = A::Output>,
    W: Future<Output = A::Output>,
    X: Future<Output = A::Output>,
    Y: Future<Output = A::Output>,
    Z: Future<Output = A::Output>,
    Aa: Future<Output = A::Output>,
    Ab: Future<Output = A::Output>,
    Ac: Future<Output = A::Output>,
    Ad: Future<Output = A::Output>,
    Ae: Future<Output = A::Output>,
    Af: Future<Output = A::Output>, 
type Output = A::Output;
[src]

impl<A> Sum32<A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A>[src]

pub fn into_inner(self) -> A[src]

Trait Implementations

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af, Target> AsMut<Target> for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: AsMut<Target>,
    B: AsMut<Target>,
    C: AsMut<Target>,
    D: AsMut<Target>,
    E: AsMut<Target>,
    F: AsMut<Target>,
    G: AsMut<Target>,
    H: AsMut<Target>,
    I: AsMut<Target>,
    J: AsMut<Target>,
    K: AsMut<Target>,
    L: AsMut<Target>,
    M: AsMut<Target>,
    N: AsMut<Target>,
    O: AsMut<Target>,
    P: AsMut<Target>,
    Q: AsMut<Target>,
    R: AsMut<Target>,
    S: AsMut<Target>,
    T: AsMut<Target>,
    U: AsMut<Target>,
    V: AsMut<Target>,
    W: AsMut<Target>,
    X: AsMut<Target>,
    Y: AsMut<Target>,
    Z: AsMut<Target>,
    Aa: AsMut<Target>,
    Ab: AsMut<Target>,
    Ac: AsMut<Target>,
    Ad: AsMut<Target>,
    Ae: AsMut<Target>,
    Af: AsMut<Target>, 
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af, Target> AsRef<Target> for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: AsRef<Target>,
    B: AsRef<Target>,
    C: AsRef<Target>,
    D: AsRef<Target>,
    E: AsRef<Target>,
    F: AsRef<Target>,
    G: AsRef<Target>,
    H: AsRef<Target>,
    I: AsRef<Target>,
    J: AsRef<Target>,
    K: AsRef<Target>,
    L: AsRef<Target>,
    M: AsRef<Target>,
    N: AsRef<Target>,
    O: AsRef<Target>,
    P: AsRef<Target>,
    Q: AsRef<Target>,
    R: AsRef<Target>,
    S: AsRef<Target>,
    T: AsRef<Target>,
    U: AsRef<Target>,
    V: AsRef<Target>,
    W: AsRef<Target>,
    X: AsRef<Target>,
    Y: AsRef<Target>,
    Z: AsRef<Target>,
    Aa: AsRef<Target>,
    Ab: AsRef<Target>,
    Ac: AsRef<Target>,
    Ad: AsRef<Target>,
    Ae: AsRef<Target>,
    Af: AsRef<Target>, 
[src]

impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone, J: Clone, K: Clone, L: Clone, M: Clone, N: Clone, O: Clone, P: Clone, Q: Clone, R: Clone, S: Clone, T: Clone, U: Clone, V: Clone, W: Clone, X: Clone, Y: Clone, Z: Clone, Aa: Clone, Ab: Clone, Ac: Clone, Ad: Clone, Ae: Clone, Af: Clone> Clone for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>[src]

impl<A: Copy, B: Copy, C: Copy, D: Copy, E: Copy, F: Copy, G: Copy, H: Copy, I: Copy, J: Copy, K: Copy, L: Copy, M: Copy, N: Copy, O: Copy, P: Copy, Q: Copy, R: Copy, S: Copy, T: Copy, U: Copy, V: Copy, W: Copy, X: Copy, Y: Copy, Z: Copy, Aa: Copy, Ab: Copy, Ac: Copy, Ad: Copy, Ae: Copy, Af: Copy> Copy for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>[src]

impl<A: Debug, B: Debug, C: Debug, D: Debug, E: Debug, F: Debug, G: Debug, H: Debug, I: Debug, J: Debug, K: Debug, L: Debug, M: Debug, N: Debug, O: Debug, P: Debug, Q: Debug, R: Debug, S: Debug, T: Debug, U: Debug, V: Debug, W: Debug, X: Debug, Y: Debug, Z: Debug, Aa: Debug, Ab: Debug, Ac: Debug, Ad: Debug, Ae: Debug, Af: Debug> Debug for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Deref for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Deref,
    B: Deref<Target = A::Target>,
    C: Deref<Target = A::Target>,
    D: Deref<Target = A::Target>,
    E: Deref<Target = A::Target>,
    F: Deref<Target = A::Target>,
    G: Deref<Target = A::Target>,
    H: Deref<Target = A::Target>,
    I: Deref<Target = A::Target>,
    J: Deref<Target = A::Target>,
    K: Deref<Target = A::Target>,
    L: Deref<Target = A::Target>,
    M: Deref<Target = A::Target>,
    N: Deref<Target = A::Target>,
    O: Deref<Target = A::Target>,
    P: Deref<Target = A::Target>,
    Q: Deref<Target = A::Target>,
    R: Deref<Target = A::Target>,
    S: Deref<Target = A::Target>,
    T: Deref<Target = A::Target>,
    U: Deref<Target = A::Target>,
    V: Deref<Target = A::Target>,
    W: Deref<Target = A::Target>,
    X: Deref<Target = A::Target>,
    Y: Deref<Target = A::Target>,
    Z: Deref<Target = A::Target>,
    Aa: Deref<Target = A::Target>,
    Ab: Deref<Target = A::Target>,
    Ac: Deref<Target = A::Target>,
    Ad: Deref<Target = A::Target>,
    Ae: Deref<Target = A::Target>,
    Af: Deref<Target = A::Target>, 
[src]

type Target = A::Target

The resulting type after dereferencing.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> DerefMut for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: DerefMut,
    B: DerefMut<Target = A::Target>,
    C: DerefMut<Target = A::Target>,
    D: DerefMut<Target = A::Target>,
    E: DerefMut<Target = A::Target>,
    F: DerefMut<Target = A::Target>,
    G: DerefMut<Target = A::Target>,
    H: DerefMut<Target = A::Target>,
    I: DerefMut<Target = A::Target>,
    J: DerefMut<Target = A::Target>,
    K: DerefMut<Target = A::Target>,
    L: DerefMut<Target = A::Target>,
    M: DerefMut<Target = A::Target>,
    N: DerefMut<Target = A::Target>,
    O: DerefMut<Target = A::Target>,
    P: DerefMut<Target = A::Target>,
    Q: DerefMut<Target = A::Target>,
    R: DerefMut<Target = A::Target>,
    S: DerefMut<Target = A::Target>,
    T: DerefMut<Target = A::Target>,
    U: DerefMut<Target = A::Target>,
    V: DerefMut<Target = A::Target>,
    W: DerefMut<Target = A::Target>,
    X: DerefMut<Target = A::Target>,
    Y: DerefMut<Target = A::Target>,
    Z: DerefMut<Target = A::Target>,
    Aa: DerefMut<Target = A::Target>,
    Ab: DerefMut<Target = A::Target>,
    Ac: DerefMut<Target = A::Target>,
    Ad: DerefMut<Target = A::Target>,
    Ae: DerefMut<Target = A::Target>,
    Af: DerefMut<Target = A::Target>, 
[src]

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Deserialize<'de> for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>,
    W: Deserialize<'de>,
    X: Deserialize<'de>,
    Y: Deserialize<'de>,
    Z: Deserialize<'de>,
    Aa: Deserialize<'de>,
    Ab: Deserialize<'de>,
    Ac: Deserialize<'de>,
    Ad: Deserialize<'de>,
    Ae: Deserialize<'de>,
    Af: Deserialize<'de>, 
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Display for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Display,
    B: Display,
    C: Display,
    D: Display,
    E: Display,
    F: Display,
    G: Display,
    H: Display,
    I: Display,
    J: Display,
    K: Display,
    L: Display,
    M: Display,
    N: Display,
    O: Display,
    P: Display,
    Q: Display,
    R: Display,
    S: Display,
    T: Display,
    U: Display,
    V: Display,
    W: Display,
    X: Display,
    Y: Display,
    Z: Display,
    Aa: Display,
    Ab: Display,
    Ac: Display,
    Ad: Display,
    Ae: Display,
    Af: Display
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> DoubleEndedIterator for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: DoubleEndedIterator,
    B: DoubleEndedIterator<Item = A::Item>,
    C: DoubleEndedIterator<Item = A::Item>,
    D: DoubleEndedIterator<Item = A::Item>,
    E: DoubleEndedIterator<Item = A::Item>,
    F: DoubleEndedIterator<Item = A::Item>,
    G: DoubleEndedIterator<Item = A::Item>,
    H: DoubleEndedIterator<Item = A::Item>,
    I: DoubleEndedIterator<Item = A::Item>,
    J: DoubleEndedIterator<Item = A::Item>,
    K: DoubleEndedIterator<Item = A::Item>,
    L: DoubleEndedIterator<Item = A::Item>,
    M: DoubleEndedIterator<Item = A::Item>,
    N: DoubleEndedIterator<Item = A::Item>,
    O: DoubleEndedIterator<Item = A::Item>,
    P: DoubleEndedIterator<Item = A::Item>,
    Q: DoubleEndedIterator<Item = A::Item>,
    R: DoubleEndedIterator<Item = A::Item>,
    S: DoubleEndedIterator<Item = A::Item>,
    T: DoubleEndedIterator<Item = A::Item>,
    U: DoubleEndedIterator<Item = A::Item>,
    V: DoubleEndedIterator<Item = A::Item>,
    W: DoubleEndedIterator<Item = A::Item>,
    X: DoubleEndedIterator<Item = A::Item>,
    Y: DoubleEndedIterator<Item = A::Item>,
    Z: DoubleEndedIterator<Item = A::Item>,
    Aa: DoubleEndedIterator<Item = A::Item>,
    Ab: DoubleEndedIterator<Item = A::Item>,
    Ac: DoubleEndedIterator<Item = A::Item>,
    Ad: DoubleEndedIterator<Item = A::Item>,
    Ae: DoubleEndedIterator<Item = A::Item>,
    Af: DoubleEndedIterator<Item = A::Item>, 
[src]

impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq, L: Eq, M: Eq, N: Eq, O: Eq, P: Eq, Q: Eq, R: Eq, S: Eq, T: Eq, U: Eq, V: Eq, W: Eq, X: Eq, Y: Eq, Z: Eq, Aa: Eq, Ab: Eq, Ac: Eq, Ad: Eq, Ae: Eq, Af: Eq> Eq for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Error for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Error,
    B: Error,
    C: Error,
    D: Error,
    E: Error,
    F: Error,
    G: Error,
    H: Error,
    I: Error,
    J: Error,
    K: Error,
    L: Error,
    M: Error,
    N: Error,
    O: Error,
    P: Error,
    Q: Error,
    R: Error,
    S: Error,
    T: Error,
    U: Error,
    V: Error,
    W: Error,
    X: Error,
    Y: Error,
    Z: Error,
    Aa: Error,
    Ab: Error,
    Ac: Error,
    Ad: Error,
    Ae: Error,
    Af: Error
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> ExactSizeIterator for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: ExactSizeIterator,
    B: ExactSizeIterator<Item = A::Item>,
    C: ExactSizeIterator<Item = A::Item>,
    D: ExactSizeIterator<Item = A::Item>,
    E: ExactSizeIterator<Item = A::Item>,
    F: ExactSizeIterator<Item = A::Item>,
    G: ExactSizeIterator<Item = A::Item>,
    H: ExactSizeIterator<Item = A::Item>,
    I: ExactSizeIterator<Item = A::Item>,
    J: ExactSizeIterator<Item = A::Item>,
    K: ExactSizeIterator<Item = A::Item>,
    L: ExactSizeIterator<Item = A::Item>,
    M: ExactSizeIterator<Item = A::Item>,
    N: ExactSizeIterator<Item = A::Item>,
    O: ExactSizeIterator<Item = A::Item>,
    P: ExactSizeIterator<Item = A::Item>,
    Q: ExactSizeIterator<Item = A::Item>,
    R: ExactSizeIterator<Item = A::Item>,
    S: ExactSizeIterator<Item = A::Item>,
    T: ExactSizeIterator<Item = A::Item>,
    U: ExactSizeIterator<Item = A::Item>,
    V: ExactSizeIterator<Item = A::Item>,
    W: ExactSizeIterator<Item = A::Item>,
    X: ExactSizeIterator<Item = A::Item>,
    Y: ExactSizeIterator<Item = A::Item>,
    Z: ExactSizeIterator<Item = A::Item>,
    Aa: ExactSizeIterator<Item = A::Item>,
    Ab: ExactSizeIterator<Item = A::Item>,
    Ac: ExactSizeIterator<Item = A::Item>,
    Ad: ExactSizeIterator<Item = A::Item>,
    Ae: ExactSizeIterator<Item = A::Item>,
    Af: ExactSizeIterator<Item = A::Item>, 
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Future for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Future,
    B: Future<Output = A::Output>,
    C: Future<Output = A::Output>,
    D: Future<Output = A::Output>,
    E: Future<Output = A::Output>,
    F: Future<Output = A::Output>,
    G: Future<Output = A::Output>,
    H: Future<Output = A::Output>,
    I: Future<Output = A::Output>,
    J: Future<Output = A::Output>,
    K: Future<Output = A::Output>,
    L: Future<Output = A::Output>,
    M: Future<Output = A::Output>,
    N: Future<Output = A::Output>,
    O: Future<Output = A::Output>,
    P: Future<Output = A::Output>,
    Q: Future<Output = A::Output>,
    R: Future<Output = A::Output>,
    S: Future<Output = A::Output>,
    T: Future<Output = A::Output>,
    U: Future<Output = A::Output>,
    V: Future<Output = A::Output>,
    W: Future<Output = A::Output>,
    X: Future<Output = A::Output>,
    Y: Future<Output = A::Output>,
    Z: Future<Output = A::Output>,
    Aa: Future<Output = A::Output>,
    Ab: Future<Output = A::Output>,
    Ac: Future<Output = A::Output>,
    Ad: Future<Output = A::Output>,
    Ae: Future<Output = A::Output>,
    Af: Future<Output = A::Output>, 
[src]

type Output = A::Output

The type of value produced on completion.

impl<A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash, J: Hash, K: Hash, L: Hash, M: Hash, N: Hash, O: Hash, P: Hash, Q: Hash, R: Hash, S: Hash, T: Hash, U: Hash, V: Hash, W: Hash, X: Hash, Y: Hash, Z: Hash, Aa: Hash, Ab: Hash, Ac: Hash, Ad: Hash, Ae: Hash, Af: Hash> Hash for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Iterator for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Iterator,
    B: Iterator<Item = A::Item>,
    C: Iterator<Item = A::Item>,
    D: Iterator<Item = A::Item>,
    E: Iterator<Item = A::Item>,
    F: Iterator<Item = A::Item>,
    G: Iterator<Item = A::Item>,
    H: Iterator<Item = A::Item>,
    I: Iterator<Item = A::Item>,
    J: Iterator<Item = A::Item>,
    K: Iterator<Item = A::Item>,
    L: Iterator<Item = A::Item>,
    M: Iterator<Item = A::Item>,
    N: Iterator<Item = A::Item>,
    O: Iterator<Item = A::Item>,
    P: Iterator<Item = A::Item>,
    Q: Iterator<Item = A::Item>,
    R: Iterator<Item = A::Item>,
    S: Iterator<Item = A::Item>,
    T: Iterator<Item = A::Item>,
    U: Iterator<Item = A::Item>,
    V: Iterator<Item = A::Item>,
    W: Iterator<Item = A::Item>,
    X: Iterator<Item = A::Item>,
    Y: Iterator<Item = A::Item>,
    Z: Iterator<Item = A::Item>,
    Aa: Iterator<Item = A::Item>,
    Ab: Iterator<Item = A::Item>,
    Ac: Iterator<Item = A::Item>,
    Ad: Iterator<Item = A::Item>,
    Ae: Iterator<Item = A::Item>,
    Af: Iterator<Item = A::Item>, 
[src]

type Item = A::Item

The type of the elements being iterated over.

impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord, L: Ord, M: Ord, N: Ord, O: Ord, P: Ord, Q: Ord, R: Ord, S: Ord, T: Ord, U: Ord, V: Ord, W: Ord, X: Ord, Y: Ord, Z: Ord, Aa: Ord, Ab: Ord, Ac: Ord, Ad: Ord, Ae: Ord, Af: Ord> Ord for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>[src]

impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J: PartialEq, K: PartialEq, L: PartialEq, M: PartialEq, N: PartialEq, O: PartialEq, P: PartialEq, Q: PartialEq, R: PartialEq, S: PartialEq, T: PartialEq, U: PartialEq, V: PartialEq, W: PartialEq, X: PartialEq, Y: PartialEq, Z: PartialEq, Aa: PartialEq, Ab: PartialEq, Ac: PartialEq, Ad: PartialEq, Ae: PartialEq, Af: PartialEq> PartialEq<Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>> for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>[src]

impl<A: PartialOrd, B: PartialOrd, C: PartialOrd, D: PartialOrd, E: PartialOrd, F: PartialOrd, G: PartialOrd, H: PartialOrd, I: PartialOrd, J: PartialOrd, K: PartialOrd, L: PartialOrd, M: PartialOrd, N: PartialOrd, O: PartialOrd, P: PartialOrd, Q: PartialOrd, R: PartialOrd, S: PartialOrd, T: PartialOrd, U: PartialOrd, V: PartialOrd, W: PartialOrd, X: PartialOrd, Y: PartialOrd, Z: PartialOrd, Aa: PartialOrd, Ab: PartialOrd, Ac: PartialOrd, Ad: PartialOrd, Ae: PartialOrd, Af: PartialOrd> PartialOrd<Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>> for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Serialize for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Serialize,
    B: Serialize,
    C: Serialize,
    D: Serialize,
    E: Serialize,
    F: Serialize,
    G: Serialize,
    H: Serialize,
    I: Serialize,
    J: Serialize,
    K: Serialize,
    L: Serialize,
    M: Serialize,
    N: Serialize,
    O: Serialize,
    P: Serialize,
    Q: Serialize,
    R: Serialize,
    S: Serialize,
    T: Serialize,
    U: Serialize,
    V: Serialize,
    W: Serialize,
    X: Serialize,
    Y: Serialize,
    Z: Serialize,
    Aa: Serialize,
    Ab: Serialize,
    Ac: Serialize,
    Ad: Serialize,
    Ae: Serialize,
    Af: Serialize
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> StructuralEq for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> StructuralPartialEq for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>[src]

Auto Trait Implementations

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> RefUnwindSafe for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: RefUnwindSafe,
    Aa: RefUnwindSafe,
    Ab: RefUnwindSafe,
    Ac: RefUnwindSafe,
    Ad: RefUnwindSafe,
    Ae: RefUnwindSafe,
    Af: RefUnwindSafe,
    B: RefUnwindSafe,
    C: RefUnwindSafe,
    D: RefUnwindSafe,
    E: RefUnwindSafe,
    F: RefUnwindSafe,
    G: RefUnwindSafe,
    H: RefUnwindSafe,
    I: RefUnwindSafe,
    J: RefUnwindSafe,
    K: RefUnwindSafe,
    L: RefUnwindSafe,
    M: RefUnwindSafe,
    N: RefUnwindSafe,
    O: RefUnwindSafe,
    P: RefUnwindSafe,
    Q: RefUnwindSafe,
    R: RefUnwindSafe,
    S: RefUnwindSafe,
    T: RefUnwindSafe,
    U: RefUnwindSafe,
    V: RefUnwindSafe,
    W: RefUnwindSafe,
    X: RefUnwindSafe,
    Y: RefUnwindSafe,
    Z: RefUnwindSafe

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Send for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Send,
    Aa: Send,
    Ab: Send,
    Ac: Send,
    Ad: Send,
    Ae: Send,
    Af: Send,
    B: Send,
    C: Send,
    D: Send,
    E: Send,
    F: Send,
    G: Send,
    H: Send,
    I: Send,
    J: Send,
    K: Send,
    L: Send,
    M: Send,
    N: Send,
    O: Send,
    P: Send,
    Q: Send,
    R: Send,
    S: Send,
    T: Send,
    U: Send,
    V: Send,
    W: Send,
    X: Send,
    Y: Send,
    Z: Send

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Sync for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Sync,
    Aa: Sync,
    Ab: Sync,
    Ac: Sync,
    Ad: Sync,
    Ae: Sync,
    Af: Sync,
    B: Sync,
    C: Sync,
    D: Sync,
    E: Sync,
    F: Sync,
    G: Sync,
    H: Sync,
    I: Sync,
    J: Sync,
    K: Sync,
    L: Sync,
    M: Sync,
    N: Sync,
    O: Sync,
    P: Sync,
    Q: Sync,
    R: Sync,
    S: Sync,
    T: Sync,
    U: Sync,
    V: Sync,
    W: Sync,
    X: Sync,
    Y: Sync,
    Z: Sync

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Unpin for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Unpin,
    Aa: Unpin,
    Ab: Unpin,
    Ac: Unpin,
    Ad: Unpin,
    Ae: Unpin,
    Af: Unpin,
    B: Unpin,
    C: Unpin,
    D: Unpin,
    E: Unpin,
    F: Unpin,
    G: Unpin,
    H: Unpin,
    I: Unpin,
    J: Unpin,
    K: Unpin,
    L: Unpin,
    M: Unpin,
    N: Unpin,
    O: Unpin,
    P: Unpin,
    Q: Unpin,
    R: Unpin,
    S: Unpin,
    T: Unpin,
    U: Unpin,
    V: Unpin,
    W: Unpin,
    X: Unpin,
    Y: Unpin,
    Z: Unpin

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> UnwindSafe for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: UnwindSafe,
    Aa: UnwindSafe,
    Ab: UnwindSafe,
    Ac: UnwindSafe,
    Ad: UnwindSafe,
    Ae: UnwindSafe,
    Af: UnwindSafe,
    B: UnwindSafe,
    C: UnwindSafe,
    D: UnwindSafe,
    E: UnwindSafe,
    F: UnwindSafe,
    G: UnwindSafe,
    H: UnwindSafe,
    I: UnwindSafe,
    J: UnwindSafe,
    K: UnwindSafe,
    L: UnwindSafe,
    M: UnwindSafe,
    N: UnwindSafe,
    O: UnwindSafe,
    P: UnwindSafe,
    Q: UnwindSafe,
    R: UnwindSafe,
    S: UnwindSafe,
    T: UnwindSafe,
    U: UnwindSafe,
    V: UnwindSafe,
    W: UnwindSafe,
    X: UnwindSafe,
    Y: UnwindSafe,
    Z: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> DeserializeOwned for T where
    T: for<'de> Deserialize<'de>, 
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<I> IntoIterator for I where
    I: Iterator
[src]

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.