forProduct20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> static method

Decoder<A> forProduct20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(
  1. Decoder<B> decodeB,
  2. Decoder<C> decodeC,
  3. Decoder<D> decodeD,
  4. Decoder<E> decodeE,
  5. Decoder<F> decodeF,
  6. Decoder<G> decodeG,
  7. Decoder<H> decodeH,
  8. Decoder<I> decodeI,
  9. Decoder<J> decodeJ,
  10. Decoder<K> decodeK,
  11. Decoder<L> decodeL,
  12. Decoder<M> decodeM,
  13. Decoder<N> decodeN,
  14. Decoder<O> decodeO,
  15. Decoder<P> decodeP,
  16. Decoder<Q> decodeQ,
  17. Decoder<R> decodeR,
  18. Decoder<S> decodeS,
  19. Decoder<T> decodeT,
  20. Decoder<U> decodeU,
  21. A fn(
    1. B,
    2. C,
    3. D,
    4. E,
    5. F,
    6. G,
    7. H,
    8. I,
    9. J,
    10. K,
    11. L,
    12. M,
    13. N,
    14. O,
    15. P,
    16. Q,
    17. R,
    18. S,
    19. T,
    20. U,
    ),
)

Implementation

static Decoder<A> forProduct20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P,
        Q, R, S, T, U>(
  Decoder<B> decodeB,
  Decoder<C> decodeC,
  Decoder<D> decodeD,
  Decoder<E> decodeE,
  Decoder<F> decodeF,
  Decoder<G> decodeG,
  Decoder<H> decodeH,
  Decoder<I> decodeI,
  Decoder<J> decodeJ,
  Decoder<K> decodeK,
  Decoder<L> decodeL,
  Decoder<M> decodeM,
  Decoder<N> decodeN,
  Decoder<O> decodeO,
  Decoder<P> decodeP,
  Decoder<Q> decodeQ,
  Decoder<R> decodeR,
  Decoder<S> decodeS,
  Decoder<T> decodeT,
  Decoder<U> decodeU,
  A Function(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) fn,
) =>
    tuple20(
            decodeB,
            decodeC,
            decodeD,
            decodeE,
            decodeF,
            decodeG,
            decodeH,
            decodeI,
            decodeJ,
            decodeK,
            decodeL,
            decodeM,
            decodeN,
            decodeO,
            decodeP,
            decodeQ,
            decodeR,
            decodeS,
            decodeT,
            decodeU)
        .map((t) => t.apply(fn));