Trait arma_rs::Factory

pub trait Factory<A, R> {
    unsafe fn call(
        &self,
        context: Context,
        output: *mut c_char,
        size: size_t,
        args: Option<*mut *mut i8>,
        count: Option<c_int>
    ) -> c_int;
}

A factory for creating a command handler. Creates a handler from any function that optionally takes a context and up to 12 arguments. The arguments must implement FromArma The return value must implement IntoExtResult

Required Methods

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
) -> c_int

Safety

This function is unsafe because it interacts with the C API.

Trait Implementations

impl<LF> Executor for dyn Factory<(), LF>where
    LF: 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

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, LF> Executor for dyn Factory<(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), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,
    O: FromArma + 'static,
    P: FromArma + 'static,
    Q: FromArma + 'static,
    R: FromArma + 'static,
    S: FromArma + 'static,
    T: FromArma + 'static,
    U: FromArma + 'static,
    V: FromArma + 'static,
    W: FromArma + 'static,
    X: FromArma + 'static,
    Y: FromArma + 'static,
    Z: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

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, LF> Executor for dyn Factory<(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), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,
    O: FromArma + 'static,
    P: FromArma + 'static,
    Q: FromArma + 'static,
    R: FromArma + 'static,
    S: FromArma + 'static,
    T: FromArma + 'static,
    U: FromArma + 'static,
    V: FromArma + 'static,
    W: FromArma + 'static,
    X: FromArma + 'static,
    Y: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

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, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,
    O: FromArma + 'static,
    P: FromArma + 'static,
    Q: FromArma + 'static,
    R: FromArma + 'static,
    S: FromArma + 'static,
    T: FromArma + 'static,
    U: FromArma + 'static,
    V: FromArma + 'static,
    W: FromArma + 'static,
    X: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,
    O: FromArma + 'static,
    P: FromArma + 'static,
    Q: FromArma + 'static,
    R: FromArma + 'static,
    S: FromArma + 'static,
    T: FromArma + 'static,
    U: FromArma + 'static,
    V: FromArma + 'static,
    W: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,
    O: FromArma + 'static,
    P: FromArma + 'static,
    Q: FromArma + 'static,
    R: FromArma + 'static,
    S: FromArma + 'static,
    T: FromArma + 'static,
    U: FromArma + 'static,
    V: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,
    O: FromArma + 'static,
    P: FromArma + 'static,
    Q: FromArma + 'static,
    R: FromArma + 'static,
    S: FromArma + 'static,
    T: FromArma + 'static,
    U: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,
    O: FromArma + 'static,
    P: FromArma + 'static,
    Q: FromArma + 'static,
    R: FromArma + 'static,
    S: FromArma + 'static,
    T: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,
    O: FromArma + 'static,
    P: FromArma + 'static,
    Q: FromArma + 'static,
    R: FromArma + 'static,
    S: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,
    O: FromArma + 'static,
    P: FromArma + 'static,
    Q: FromArma + 'static,
    R: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,
    O: FromArma + 'static,
    P: FromArma + 'static,
    Q: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,
    O: FromArma + 'static,
    P: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,
    O: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,
    N: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,
    M: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, LF> Executor for dyn Factory<(A, B, C, D, E, F, G, H), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, LF> Executor for dyn Factory<(A, B, C, D, E, F, G), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, LF> Executor for dyn Factory<(A, B, C, D, E, F), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, LF> Executor for dyn Factory<(A, B, C, D, E), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, LF> Executor for dyn Factory<(A, B, C, D), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, LF> Executor for dyn Factory<(A, B, C), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, LF> Executor for dyn Factory<(A, B), LF>where
    LF: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, LF> Executor for dyn Factory<(A,), LF>where
    LF: 'static,
    A: FromArma + 'static,

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

Implementors

impl<Func, A, B, C, D, E, ER> Factory<(Context, A, B, C, D, E), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,

impl<Func, A, B, C, D, E, ER> Factory<(A, B, C, D, E), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,

impl<Func, A, B, C, D, E, F, ER> Factory<(Context, A, B, C, D, E, F), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,

impl<Func, A, B, C, D, E, F, ER> Factory<(A, B, C, D, E, F), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,

impl<Func, A, B, C, D, E, F, G, ER> Factory<(Context, A, B, C, D, E, F, G), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,

impl<Func, A, B, C, D, E, F, G, ER> Factory<(A, B, C, D, E, F, G), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,

impl<Func, A, B, C, D, E, F, G, H, ER> Factory<(Context, A, B, C, D, E, F, G, H), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,

impl<Func, A, B, C, D, E, F, G, H, ER> Factory<(A, B, C, D, E, F, G, H), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, ER> Factory<(Context, A, B, C, D, E, F, G, H, I), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, ER> Factory<(A, B, C, D, E, F, G, H, I), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, ER> Factory<(A, B, C, D, E, F, G, H, I, J), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L, M), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L, M) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,
    U: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,
    U: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,
    U: FromArma,
    V: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,
    U: FromArma,
    V: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,
    U: FromArma,
    V: FromArma,
    W: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,
    U: FromArma,
    V: FromArma,
    W: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, ER> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,
    U: FromArma,
    V: FromArma,
    W: FromArma,
    X: FromArma,

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, ER> Factory<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,
    U: FromArma,
    V: FromArma,
    W: FromArma,
    X: FromArma,

impl<Func, 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, ER> Factory<(Context, 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), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, 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) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,
    U: FromArma,
    V: FromArma,
    W: FromArma,
    X: FromArma,
    Y: FromArma,

impl<Func, 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, ER> Factory<(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), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(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) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,
    U: FromArma,
    V: FromArma,
    W: FromArma,
    X: FromArma,
    Y: FromArma,

impl<Func, 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, ER> Factory<(Context, 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), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, 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) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,
    U: FromArma,
    V: FromArma,
    W: FromArma,
    X: FromArma,
    Y: FromArma,
    Z: FromArma,

impl<Func, 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, ER> Factory<(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), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(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) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma,
    M: FromArma,
    N: FromArma,
    O: FromArma,
    P: FromArma,
    Q: FromArma,
    R: FromArma,
    S: FromArma,
    T: FromArma,
    U: FromArma,
    V: FromArma,
    W: FromArma,
    X: FromArma,
    Y: FromArma,
    Z: FromArma,

impl<Func, A, B, C, D, ER> Factory<(Context, A, B, C, D), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C, D) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,

impl<Func, A, B, C, D, ER> Factory<(A, B, C, D), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C, D) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,

impl<Func, A, B, C, ER> Factory<(Context, A, B, C), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B, C) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,

impl<Func, A, B, C, ER> Factory<(A, B, C), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B, C) -> ER,
    A: FromArma,
    B: FromArma,
    C: FromArma,

impl<Func, A, B, ER> Factory<(Context, A, B), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A, B) -> ER,
    A: FromArma,
    B: FromArma,

impl<Func, A, B, ER> Factory<(A, B), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A, B) -> ER,
    A: FromArma,
    B: FromArma,

impl<Func, A, ER> Factory<(Context, A), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context, A) -> ER,
    A: FromArma,

impl<Func, A, ER> Factory<(A,), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(A) -> ER,
    A: FromArma,

impl<Func, ER> Factory<(Context,), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn(Context) -> ER,

impl<Func, ER> Factory<(), ER> for Funcwhere
    ER: IntoExtResult + 'static,
    Func: Fn() -> ER,