tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M> static method

Decoder<(A, B, C, D, E, F, G, H, I, J, K, L, M)> tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>(
  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,
)

Implementation

static Decoder<(A, B, C, D, E, F, G, H, I, J, K, L, M)>
    tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>(
  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,
) =>
        _DecoderF((bv) => tuple12(decodeA, decodeB, decodeC, decodeD, decodeE,
                decodeF, decodeG, decodeH, decodeI, decodeJ, decodeK, decodeL)
            .decode(bv)
            .flatMap((t) => decodeM.decode(t.remainder).map(
                (m) => DecodeResult(t.value.append(m.value), m.remainder))));