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