Trait diesel::expression::AsExpressionList

pub trait AsExpressionList<ST> {
    type Expression;
    fn as_expression_list(self) -> Self::Expression;
}

Converts a tuple of values into a tuple of Diesel expressions.

This trait is similar to AsExpression, but it operates on tuples. The expressions must all be of the same SQL type.

Associated Types

type Expression

The final output expression

Required methods

fn as_expression_list(self) -> Self::Expression

Perform the conversion

Implementations on Foreign Types

impl<A, ST> AsExpressionList<ST> for (A,) where
    A: AsExpression<ST>, 

type Expression = (A::Expression,)

fn as_expression_list(self) -> Self::Expression

impl<A, B, ST> AsExpressionList<ST> for (A, B) where
    A: AsExpression<ST>,
    B: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, ST> AsExpressionList<ST> for (A, B, C) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, ST> AsExpressionList<ST> for (A, B, C, D) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, ST> AsExpressionList<ST> for (A, B, C, D, E) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, ST> AsExpressionList<ST> for (A, B, C, D, E, F) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, L, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>,
    U: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>,
    U: AsExpression<ST>,
    V: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression)

fn as_expression_list(self) -> Self::Expression

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>,
    U: AsExpression<ST>,
    V: AsExpression<ST>,
    W: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression)

fn as_expression_list(self) -> Self::Expression

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, ST> AsExpressionList<ST> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>,
    U: AsExpression<ST>,
    V: AsExpression<ST>,
    W: AsExpression<ST>,
    X: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression)

fn as_expression_list(self) -> Self::Expression

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, ST> AsExpressionList<ST> for (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) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>,
    U: AsExpression<ST>,
    V: AsExpression<ST>,
    W: AsExpression<ST>,
    X: AsExpression<ST>,
    Y: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression)

fn as_expression_list(self) -> Self::Expression

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, ST> AsExpressionList<ST> for (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) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>,
    U: AsExpression<ST>,
    V: AsExpression<ST>,
    W: AsExpression<ST>,
    X: AsExpression<ST>,
    Y: AsExpression<ST>,
    Z: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression)

fn as_expression_list(self) -> Self::Expression

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, ST> AsExpressionList<ST> for (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) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>,
    U: AsExpression<ST>,
    V: AsExpression<ST>,
    W: AsExpression<ST>,
    X: AsExpression<ST>,
    Y: AsExpression<ST>,
    Z: AsExpression<ST>,
    AA: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression)

fn as_expression_list(self) -> Self::Expression

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, ST> AsExpressionList<ST> for (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) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>,
    U: AsExpression<ST>,
    V: AsExpression<ST>,
    W: AsExpression<ST>,
    X: AsExpression<ST>,
    Y: AsExpression<ST>,
    Z: AsExpression<ST>,
    AA: AsExpression<ST>,
    AB: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression)

fn as_expression_list(self) -> Self::Expression

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, ST> AsExpressionList<ST> for (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) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>,
    U: AsExpression<ST>,
    V: AsExpression<ST>,
    W: AsExpression<ST>,
    X: AsExpression<ST>,
    Y: AsExpression<ST>,
    Z: AsExpression<ST>,
    AA: AsExpression<ST>,
    AB: AsExpression<ST>,
    AC: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression)

fn as_expression_list(self) -> Self::Expression

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, ST> AsExpressionList<ST> for (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) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>,
    U: AsExpression<ST>,
    V: AsExpression<ST>,
    W: AsExpression<ST>,
    X: AsExpression<ST>,
    Y: AsExpression<ST>,
    Z: AsExpression<ST>,
    AA: AsExpression<ST>,
    AB: AsExpression<ST>,
    AC: AsExpression<ST>,
    AD: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression)

fn as_expression_list(self) -> Self::Expression

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, ST> AsExpressionList<ST> for (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) where
    A: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>,
    U: AsExpression<ST>,
    V: AsExpression<ST>,
    W: AsExpression<ST>,
    X: AsExpression<ST>,
    Y: AsExpression<ST>,
    Z: AsExpression<ST>,
    AA: AsExpression<ST>,
    AB: AsExpression<ST>,
    AC: AsExpression<ST>,
    AD: AsExpression<ST>,
    AE: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression, AE::Expression)

fn as_expression_list(self) -> Self::Expression

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, ST> AsExpressionList<ST> for (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: AsExpression<ST>,
    B: AsExpression<ST>,
    C: AsExpression<ST>,
    D: AsExpression<ST>,
    E: AsExpression<ST>,
    F: AsExpression<ST>,
    G: AsExpression<ST>,
    H: AsExpression<ST>,
    I: AsExpression<ST>,
    J: AsExpression<ST>,
    K: AsExpression<ST>,
    L: AsExpression<ST>,
    M: AsExpression<ST>,
    N: AsExpression<ST>,
    O: AsExpression<ST>,
    P: AsExpression<ST>,
    Q: AsExpression<ST>,
    R: AsExpression<ST>,
    S: AsExpression<ST>,
    T: AsExpression<ST>,
    U: AsExpression<ST>,
    V: AsExpression<ST>,
    W: AsExpression<ST>,
    X: AsExpression<ST>,
    Y: AsExpression<ST>,
    Z: AsExpression<ST>,
    AA: AsExpression<ST>,
    AB: AsExpression<ST>,
    AC: AsExpression<ST>,
    AD: AsExpression<ST>,
    AE: AsExpression<ST>,
    AF: AsExpression<ST>, 

type Expression = (A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression, AE::Expression, AF::Expression)

fn as_expression_list(self) -> Self::Expression

Implementors