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

Encoder<A> forProduct16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
  1. Encoder<B> encodeB,
  2. Encoder<C> encodeC,
  3. Encoder<D> encodeD,
  4. Encoder<E> encodeE,
  5. Encoder<F> encodeF,
  6. Encoder<G> encodeG,
  7. Encoder<H> encodeH,
  8. Encoder<I> encodeI,
  9. Encoder<J> encodeJ,
  10. Encoder<K> encodeK,
  11. Encoder<L> encodeL,
  12. Encoder<M> encodeM,
  13. Encoder<N> encodeN,
  14. Encoder<O> encodeO,
  15. Encoder<P> encodeP,
  16. Encoder<Q> encodeQ,
  17. Tuple16<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> fn(
    1. A
    ),
)

Implementation

static Encoder<A>
    forProduct16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
  Encoder<B> encodeB,
  Encoder<C> encodeC,
  Encoder<D> encodeD,
  Encoder<E> encodeE,
  Encoder<F> encodeF,
  Encoder<G> encodeG,
  Encoder<H> encodeH,
  Encoder<I> encodeI,
  Encoder<J> encodeJ,
  Encoder<K> encodeK,
  Encoder<L> encodeL,
  Encoder<M> encodeM,
  Encoder<N> encodeN,
  Encoder<O> encodeO,
  Encoder<P> encodeP,
  Encoder<Q> encodeQ,
  Tuple16<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> Function(A) fn,
) =>
        Encoder._unkeyed((a) => tuple16(
                encodeB,
                encodeC,
                encodeD,
                encodeE,
                encodeF,
                encodeG,
                encodeH,
                encodeI,
                encodeJ,
                encodeK,
                encodeL,
                encodeM,
                encodeN,
                encodeO,
                encodeP,
                encodeQ)
            .encode(fn(a)));