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

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

Implementation

static Decoder<Tuple18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>>
    tuple18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
  Decoder<A> decodeA,
  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,
) =>
        tuple17(
                decodeA,
                decodeB,
                decodeC,
                decodeD,
                decodeE,
                decodeF,
                decodeG,
                decodeH,
                decodeI,
                decodeJ,
                decodeK,
                decodeL,
                decodeM,
                decodeN,
                decodeO,
                decodeP,
                decodeQ)
            .flatMap((t17) => decodeR.map(t17.append));