Trait printf_wrap::PrintfArgs

pub trait PrintfArgs {
    type AsList: PrintfArgsList;
}

A list of Rust-side arguments to a printf(3)-style function.

Required Associated Types

type AsList: PrintfArgsList

The PrintfArgsList equivalent to Self.

Implementations on Foreign Types

impl PrintfArgs for ()

type AsList = ()

impl<A> PrintfArgs for (A,)where
    A: PrintfArgument,

type AsList = (A, ())

impl<A, B> PrintfArgs for (A, B)where
    A: PrintfArgument,
    B: PrintfArgument,

type AsList = (A, (B, ()))

impl<A, B, C> PrintfArgs for (A, B, C)where
    A: PrintfArgument,
    B: PrintfArgument,
    C: PrintfArgument,

type AsList = (A, (B, (C, ())))

impl<A, B, C, D> PrintfArgs for (A, B, C, D)where
    A: PrintfArgument,
    B: PrintfArgument,
    C: PrintfArgument,
    D: PrintfArgument,

type AsList = (A, (B, (C, (D, ()))))

impl<A, B, C, D, E> PrintfArgs for (A, B, C, D, E)where
    A: PrintfArgument,
    B: PrintfArgument,
    C: PrintfArgument,
    D: PrintfArgument,
    E: PrintfArgument,

type AsList = (A, (B, (C, (D, (E, ())))))

impl<A, B, C, D, E, F> PrintfArgs for (A, B, C, D, E, F)where
    A: PrintfArgument,
    B: PrintfArgument,
    C: PrintfArgument,
    D: PrintfArgument,
    E: PrintfArgument,
    F: PrintfArgument,

type AsList = (A, (B, (C, (D, (E, (F, ()))))))

impl<A, B, C, D, E, F, G> PrintfArgs for (A, B, C, D, E, F, G)where
    A: PrintfArgument,
    B: PrintfArgument,
    C: PrintfArgument,
    D: PrintfArgument,
    E: PrintfArgument,
    F: PrintfArgument,
    G: PrintfArgument,

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

impl<A, B, C, D, E, F, G, H> PrintfArgs for (A, B, C, D, E, F, G, H)where
    A: PrintfArgument,
    B: PrintfArgument,
    C: PrintfArgument,
    D: PrintfArgument,
    E: PrintfArgument,
    F: PrintfArgument,
    G: PrintfArgument,
    H: PrintfArgument,

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

impl<A, B, C, D, E, F, G, H, I> PrintfArgs for (A, B, C, D, E, F, G, H, I)where
    A: PrintfArgument,
    B: PrintfArgument,
    C: PrintfArgument,
    D: PrintfArgument,
    E: PrintfArgument,
    F: PrintfArgument,
    G: PrintfArgument,
    H: PrintfArgument,
    I: PrintfArgument,

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

impl<A, B, C, D, E, F, G, H, I, J> PrintfArgs for (A, B, C, D, E, F, G, H, I, J)where
    A: PrintfArgument,
    B: PrintfArgument,
    C: PrintfArgument,
    D: PrintfArgument,
    E: PrintfArgument,
    F: PrintfArgument,
    G: PrintfArgument,
    H: PrintfArgument,
    I: PrintfArgument,
    J: PrintfArgument,

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

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

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

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

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

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

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

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

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

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

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

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

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

Implementors

impl<T: PrintfArgument> PrintfArgs for T

type AsList = (T, ())