Ribs

Appearance

ribs_binary›Classes›Codec<A>

Codec<A> abstract ​

abstractclassCodec<A>extendsEncoder<A>withDecoder<A>

Defines a typeclass capable of both encoding to and decoding from binary data.

Inheritance

Object → Encoder<A> → Codec<A>

Mixed-in types

Available Extensions

Constructors ​

Codec() ​

Codec()

Properties ​

description no setter ​

String?getdescription

An optional description of this codec.

Implementation
dart
String? get description => null;

hashCode no setter inherited ​

intgethashCode

The hash code for this object.

A hash code is a single integer which represents the state of the object that affects operator == comparisons.

All objects have hash codes. The default hash code implemented by Object represents only the identity of the object, the same way as the default operator == implementation only considers objects equal if they are identical (see identityHashCode).

If operator == is overridden to use the object state instead, the hash code must also be changed to represent that state, otherwise the object cannot be used in hash based data structures like the default Set and Map implementations.

Hash codes must be the same for objects that are equal to each other according to operator ==. The hash code of an object should only change if the object changes in a way that affects equality. There are no further requirements for the hash codes. They need not be consistent between executions of the same program and there are no distribution guarantees.

Objects that are not equal are allowed to have the same hash code. It is even technically allowed that all instances have the same hash code, but if clashes happen too often, it may reduce the efficiency of hash-based data structures like HashSet or HashMap.

If a subclass overrides hashCode, it should override the operator == operator as well to maintain consistency.

Inherited from Object.

Implementation
dart
external int get hashCode;

runtimeType no setter inherited ​

TypegetruntimeType

A representation of the runtime type of the object.

Inherited from Object.

Implementation
dart
external Type get runtimeType;

tag no setter ​

Typegettag

The runtime type of the value this codec handles.

Implementation
dart
Type get tag => A;

Methods ​

contramap() inherited ​

Encoder<B>contramap<B>(AFunction(B)f)

Adapts this encoder to accept values of B by first applying f.

Inherited from Encoder.

Implementation
dart
Encoder<B> contramap<B>(Function1<B, A> f) => Encoder.instance<B>((b) => encode(f(b)));

decode() override ​

Either<Err,DecodeResult<A>>decode(BitVectorbv)

Decodes a value from the start of bv, returning the decoded value and any unconsumed remainder, or an Err on failure.

Implementation
dart
@override
Either<Err, DecodeResult<A>> decode(BitVector bv);

emap() inherited ​

Decoder<B>emap<B>(Either<Err,B>Function(A)f)

Like map, but allows the transform f to fail with an Err.

Inherited from Decoder.

Implementation
dart
Decoder<B> emap<B>(Function1<A, Either<Err, B>> f) => instance(
  (bv) => decode(bv).flatMap((a) => f(a.value).map((b) => DecodeResult(b, a.remainder))),
);

encode() override ​

Either<Err,BitVector>encode(Aa)

Encodes a single value of A to a BitVector.

Implementation
dart
@override
Either<Err, BitVector> encode(A a);

encodeAll() inherited ​

Either<Err,BitVector>encodeAll(Iterable<A>as)

Encodes all values in as and concatenates the resulting bits.

Inherited from Encoder.

Implementation
dart
Either<Err, BitVector> encodeAll(Iterable<A> as) => as.fold(
  Either.right(BitVector.empty),
  (acc, a) => encode(a).flatMap((res) => acc.map((acc) => acc.concat(res))),
);

flatMap() inherited ​

Decoder<B>flatMap<B>(Decoder<B>Function(A)f)

Chains this decoder with another selected by the decoded value.

Inherited from Decoder.

Implementation
dart
Decoder<B> flatMap<B>(Function1<A, Decoder<B>> f) =>
    instance((bv) => decode(bv).flatMap((a) => f(a.value).decode(a.remainder)));

map() inherited ​

Decoder<B>map<B>(BFunction(A)f)

Transforms the successfully decoded value using f.

Inherited from Decoder.

Implementation
dart
Decoder<B> map<B>(Function1<A, B> f) =>
    instance<B>((bv) => decode(bv).map((a) => DecodeResult(f(a.value), a.remainder)));

noSuchMethod() inherited ​

dynamicnoSuchMethod(Invocationinvocation)

Invoked when a nonexistent method or property is accessed.

A dynamic member invocation can attempt to call a member which doesn't exist on the receiving object. Example:

dart
dynamic object = 1;
object.add(42); // Statically allowed, run-time error

This invalid code will invoke the noSuchMethod method of the integer 1 with an Invocation representing the .add(42) call and arguments (which then throws).

Classes can override noSuchMethod to provide custom behavior for such invalid dynamic invocations.

A class with a non-default noSuchMethod invocation can also omit implementations for members of its interface. Example:

dart
class MockList<T> implements List<T> {
  noSuchMethod(Invocation invocation) {
    log(invocation);
    super.noSuchMethod(invocation); // Will throw.
  }
}
void main() {
  MockList().add(42);
}

This code has no compile-time warnings or errors even though the MockList class has no concrete implementation of any of the List interface methods. Calls to List methods are forwarded to noSuchMethod, so this code will log an invocation similar to Invocation.method(#add, [42]) and then throw.

If a value is returned from noSuchMethod, it becomes the result of the original invocation. If the value is not of a type that can be returned by the original invocation, a type error occurs at the invocation.

The default behavior is to throw a NoSuchMethodError.

Inherited from Object.

Implementation
dart
@pragma("vm:entry-point")
@pragma("wasm:entry-point")
external dynamic noSuchMethod(Invocation invocation);

prepend() ​

Codec<Record>prepend<B>(Codec<B>Function(A)codecB)
Implementation
dart
Codec<(A, B)> prepend<B>(Function1<A, Codec<B>> codecB) => Codec.of(
  flatMap((a) => codecB(a).map((b) => (a, b))),
  Encoder.instance<(A, B)>((t) => Encoder.encodeBoth(this, t.$1, codecB(t.$1), t.$2)),
  description: 'prepend($this)',
);

toString() override ​

StringtoString()

A string representation of this object.

Some classes have a default textual representation, often paired with a static parse function (like int.parse). These classes will provide the textual representation as their string representation.

Other classes have no meaningful textual representation that a program will care about. Such classes will typically override toString to provide useful information when inspecting the object, mainly for debugging or logging.

Implementation
dart
@override
String toString() => description ?? super.toString();

withDescription() ​

Codec<A>withDescription(Stringdescription)

Returns a new Codec with the given description.

Implementation
dart
Codec<A> withDescription(String description) => Codec.of(this, this, description: description);

xmap() ​

Codec<B>xmap<B>(BFunction(A)f,AFunction(B)g)

Creates a new codec by mapping the value type A to B and vice versa.

Implementation
dart
Codec<B> xmap<B>(Function1<A, B> f, Function1<B, A> g) => Codec.of(map(f), contramap(g));

Extension Methods ​

optional() extension ​

Codec<Option<A>>optional(Codec<bool>indicator)

Available on Codec<A>, provided by the CodecOps<A> extension

Implementation
dart
Codec<Option<A>> optional(Codec<bool> indicator) => Codec.option(indicator, this);

Operators ​

operator ==() inherited ​

booloperator ==(Objectother)

The equality operator.

The default behavior for all Objects is to return true if and only if this object and other are the same object.

Override this method to specify a different equality relation on a class. The overriding method must still be an equivalence relation. That is, it must be:

  • Total: It must return a boolean for all arguments. It should never throw.

  • Reflexive: For all objects o, o == o must be true.

  • Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must either both be true, or both be false.

  • Transitive: For all objects o1, o2, and o3, if o1 == o2 and o2 == o3 are true, then o1 == o3 must be true.

The method should also be consistent over time, so whether two objects are equal should only change if at least one of the objects was modified.

If a subclass overrides the equality operator, it should override the hashCode method as well to maintain consistency.

Inherited from Object.

Implementation
dart
external bool operator ==(Object other);

Static Properties ​

ascii final ​

finalCodec<String>ascii
Implementation
dart
static final Codec<String> ascii = StringCodec.acsii();

ascii32 final ​

finalCodec<String>ascii32
Implementation
dart
static final Codec<String> ascii32 = VariableSizedCodec(int32, ascii);

ascii32L final ​

finalCodec<String>ascii32L
Implementation
dart
static final Codec<String> ascii32L = VariableSizedCodec(int32L, ascii);

bits final ​

finalCodec<BitVector>bits
Implementation
dart
static final Codec<BitVector> bits = Codec.of(
  Decoder.instance((b) => Either.right(DecodeResult.successful(b))),
  Encoder.instance((b) => Either.right(b)),
  description: 'bits',
);

boolean final ​

finalCodec<bool>boolean
Implementation
dart
static final Codec<bool> boolean = BooleanCodec();

bytes final ​

finalCodec<ByteVector>bytes
Implementation
dart
static final Codec<ByteVector> bytes = bits
    .xmap((bits) => bits.bytes, (bytes) => bytes.bits)
    .withDescription('bytes');

cstring final ​

finalCodec<String>cstring
Implementation
dart
static final Codec<String> cstring = StringCodec.cstring();

float32 final ​

finalCodec<double>float32
Implementation
dart
static final Codec<double> float32 = FloatCodec.float32(Endian.big);

float32L final ​

finalCodec<double>float32L
Implementation
dart
static final Codec<double> float32L = FloatCodec.float32(Endian.little);

float64 final ​

finalCodec<double>float64
Implementation
dart
static final Codec<double> float64 = FloatCodec.float64(Endian.big);

float64L final ​

finalCodec<double>float64L
Implementation
dart
static final Codec<double> float64L = FloatCodec.float64(Endian.little);

int16 final ​

finalCodec<int>int16
Implementation
dart
static final Codec<int> int16 = IntCodec(16, true, Endian.big);

int16L final ​

finalCodec<int>int16L
Implementation
dart
static final Codec<int> int16L = IntCodec(16, true, Endian.little);

int24 final ​

finalCodec<int>int24
Implementation
dart
static final Codec<int> int24 = IntCodec(24, true, Endian.big);

int24L final ​

finalCodec<int>int24L
Implementation
dart
static final Codec<int> int24L = IntCodec(24, true, Endian.little);

int32 final ​

finalCodec<int>int32
Implementation
dart
static final Codec<int> int32 = IntCodec(32, true, Endian.big);

int32L final ​

finalCodec<int>int32L
Implementation
dart
static final Codec<int> int32L = IntCodec(32, true, Endian.little);

int4 final ​

finalCodec<int>int4
Implementation
dart
static final Codec<int> int4 = IntCodec(4, true, Endian.big);

int4L final ​

finalCodec<int>int4L
Implementation
dart
static final Codec<int> int4L = IntCodec(4, true, Endian.little);

int64 final ​

finalCodec<int>int64
Implementation
dart
static final Codec<int> int64 = IntCodec(64, true, Endian.big);

int64L final ​

finalCodec<int>int64L
Implementation
dart
static final Codec<int> int64L = IntCodec(64, true, Endian.little);

int8 final ​

finalCodec<int>int8
Implementation
dart
static final Codec<int> int8 = IntCodec(8, true, Endian.big);

int8L final ​

finalCodec<int>int8L
Implementation
dart
static final Codec<int> int8L = IntCodec(8, true, Endian.little);

uint16 final ​

finalCodec<int>uint16
Implementation
dart
static final Codec<int> uint16 = IntCodec(16, false, Endian.big);

uint16L final ​

finalCodec<int>uint16L
Implementation
dart
static final Codec<int> uint16L = IntCodec(16, false, Endian.little);

uint24 final ​

finalCodec<int>uint24
Implementation
dart
static final Codec<int> uint24 = IntCodec(24, false, Endian.big);

uint24L final ​

finalCodec<int>uint24L
Implementation
dart
static final Codec<int> uint24L = IntCodec(24, false, Endian.little);

uint32 final ​

finalCodec<int>uint32
Implementation
dart
static final Codec<int> uint32 = IntCodec(32, false, Endian.big);

uint32L final ​

finalCodec<int>uint32L
Implementation
dart
static final Codec<int> uint32L = IntCodec(32, false, Endian.little);

uint4 final ​

finalCodec<int>uint4
Implementation
dart
static final Codec<int> uint4 = IntCodec(4, false, Endian.big);

uint4L final ​

finalCodec<int>uint4L
Implementation
dart
static final Codec<int> uint4L = IntCodec(4, false, Endian.little);

uint8 final ​

finalCodec<int>uint8
Implementation
dart
static final Codec<int> uint8 = IntCodec(8, false, Endian.big);

uint8L final ​

finalCodec<int>uint8L
Implementation
dart
static final Codec<int> uint8L = IntCodec(8, false, Endian.little);

utf16 final ​

finalCodec<String>utf16
Implementation
dart
static final Codec<String> utf16 = StringCodec.utf16();

utf16_32 final ​

finalCodec<String>utf16_32
Implementation
dart
static final Codec<String> utf16_32 = VariableSizedCodec(int32, utf16);

utf16_32L final ​

finalCodec<String>utf16_32L
Implementation
dart
static final Codec<String> utf16_32L = VariableSizedCodec(int32L, utf16);

utf8 final ​

finalCodec<String>utf8
Implementation
dart
static final Codec<String> utf8 = StringCodec.utf8();

utf8_32 final ​

finalCodec<String>utf8_32
Implementation
dart
static final Codec<String> utf8_32 = VariableSizedCodec(int32, utf8);

utf8_32L final ​

finalCodec<String>utf8_32L
Implementation
dart
static final Codec<String> utf8_32L = VariableSizedCodec(int32L, utf8);

Static Methods ​

bitsN() ​

Codec<BitVector>bitsN(intsize)
Implementation
dart
static Codec<BitVector> bitsN(int size) => FixedSizeCodec(size, bits);

bitsStrict() ​

Codec<BitVector>bitsStrict(intsize)
Implementation
dart
static Codec<BitVector> bitsStrict(int size) => FixedSizeStrictCodec(size, bits);

booleanN() ​

Codec<bool>booleanN(intsize)
Implementation
dart
static Codec<bool> booleanN(int size) {
  final zeros = BitVector.low(size);
  final ones = BitVector.high(size);
  return bitsN(size).xmap<bool>((b) => b != zeros, (b) => b ? ones : zeros);
}

byteAligned() ​

Codec<A>byteAligned<A>(Codec<A>codec)
Implementation
dart
static Codec<A> byteAligned<A>(Codec<A> codec) => ByteAlignedCodec(codec);

bytesN() ​

Codec<ByteVector>bytesN(intsize)
Implementation
dart
static Codec<ByteVector> bytesN(int size) => FixedSizeCodec(size * 8, bytes);

bytesStrict() ​

Codec<ByteVector>bytesStrict(intsize)
Implementation
dart
static Codec<ByteVector> bytesStrict(int size) => FixedSizeStrictCodec(size * 8, bytes);

choice() ​

Codec<A>choice<A>(List<Codec<A>>choices)
Implementation
dart
static Codec<A> choice<A>(List<Codec<A>> choices) => ChoiceCodec(choices.toIList());

constant() ​

Codec<Unit>constant(BitVectorbytes)
Implementation
dart
static Codec<Unit> constant(BitVector bytes) => ConstantCodec(bytes);

discriminatedBy() ​

Codec<B>discriminatedBy<A, B>(Codec<A>by,IMap<A,Codec<B>>typecases,AFunction(B)getDiscriminator,);
Implementation
dart
static Codec<B> discriminatedBy<A, B>(
  Codec<A> by,
  IMap<A, Codec<B>> typecases,
  A Function(B) getDiscriminator,
) => DiscriminatorCodec.typecases(by, typecases, getDiscriminator);

either() ​

Codec<Either<A,B>>either<A, B>(Codec<bool>indicator,Codec<A>leftCodec,Codec<B>rightCodec,);
Implementation
dart
static Codec<Either<A, B>> either<A, B>(
  Codec<bool> indicator,
  Codec<A> leftCodec,
  Codec<B> rightCodec,
) => EitherCodec(indicator, leftCodec, rightCodec);

ignore() ​

Codec<Unit>ignore(intsize)
Implementation
dart
static Codec<Unit> ignore(int size) => IgnoreCodec(size);

ilist() ​

Codec<IList<A>>ilist<A>(Codec<A>codec, [int?limit])
Implementation
dart
static Codec<IList<A>> ilist<A>(Codec<A> codec, [int? limit]) =>
    list(codec, limit).xmap(IList.fromDart, (il) => il.toList());

ilistOfN() ​

Codec<IList<A>>ilistOfN<A>(Codec<int>countCodec,Codec<A>valueCodec,);
Implementation
dart
static Codec<IList<A>> ilistOfN<A>(Codec<int> countCodec, Codec<A> valueCodec) =>
    listOfN(countCodec, valueCodec).xmap(IList.fromDart, (il) => il.toList());

integer() ​

Codec<int>integer(intsize)
Implementation
dart
static Codec<int> integer(int size) => IntCodec(size, true, Endian.big);

integerL() ​

Codec<int>integerL(intsize)
Implementation
dart
static Codec<int> integerL(int size) => IntCodec(size, true, Endian.little);

list() ​

Codec<List<A>>list<A>(Codec<A>codec, [int?limit])
Implementation
dart
static Codec<List<A>> list<A>(Codec<A> codec, [int? limit]) =>
    ListCodec(codec, limit: Option(limit));

listOfN() ​

Codec<List<A>>listOfN<A>(Codec<int>countCodec,Codec<A>valueCodec)
Implementation
dart
static Codec<List<A>> listOfN<A>(Codec<int> countCodec, Codec<A> valueCodec) => Codec.of(
  countCodec.flatMap((count) => list(valueCodec, count)),
  Encoder.instance(
    (as) => countCodec
        .encode(as.length)
        .flatMap((x) => valueCodec.encodeAll(as).map((y) => x.concat(y))),
  ),
);

of() ​

Codec<A>of<A>(Decoder<A>decoder,Encoder<A>encoder, {String?description,});

Creates a Codec from a Decoder and an Encoder.

Implementation
dart
static Codec<A> of<A>(
  Decoder<A> decoder,
  Encoder<A> encoder, {
  String? description,
}) => _CodecF(decoder, encoder, description: description);

option() ​

Codec<Option<A>>option<A>(Codec<bool>indicator,Codec<A>valueCodec)
Implementation
dart
static Codec<Option<A>> option<A>(Codec<bool> indicator, Codec<A> valueCodec) => either(
  indicator,
  provide(null),
  valueCodec,
).xmap((a) => a.toOption(), (a) => a.toRight(() => null));

peek() ​

Codec<A>peek<A>(Codec<A>target)
Implementation
dart
static Codec<A> peek<A>(Codec<A> target) => Codec.of(
  Decoder.instance((b) => target.decode(b).map((a) => a.mapRemainder((_) => b))),
  target,
  description: 'peek($target)',
);

product10() ​

Codec<T10>product10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,T10Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,)apply,RecordFunction(T10)tupled,);
Implementation
dart
static Codec<T10> product10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Function10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> apply,
  Function1<T10, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> tupled,
) => tuple10(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
).xmap(apply.tupled, tupled);

product11() ​

Codec<T11>product11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,T11Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,)apply,RecordFunction(T11)tupled,);
Implementation
dart
static Codec<T11> product11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Function11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> apply,
  Function1<T11, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> tupled,
) => tuple11(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
  codec10,
).xmap(apply.tupled, tupled);

product12() ​

Codec<T12>product12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,T12Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,)apply,RecordFunction(T12)tupled,);
Implementation
dart
static Codec<T12> product12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Function12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> apply,
  Function1<T12, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> tupled,
) => tuple12(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
  codec10,
  codec11,
).xmap(apply.tupled, tupled);

product13() ​

Codec<T13>product13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,T13Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,)apply,RecordFunction(T13)tupled,);
Implementation
dart
static Codec<T13> product13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Function13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> apply,
  Function1<T13, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> tupled,
) => tuple13(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
  codec10,
  codec11,
  codec12,
).xmap(apply.tupled, tupled);

product14() ​

Codec<T14>product14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,T14Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,)apply,RecordFunction(T14)tupled,);
Implementation
dart
static Codec<T14> product14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Function14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> apply,
  Function1<T14, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> tupled,
) => tuple14(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
  codec10,
  codec11,
  codec12,
  codec13,
).xmap(apply.tupled, tupled);

product15() ​

Codec<T15>product15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,T15Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,)apply,RecordFunction(T15)tupled,);
Implementation
dart
static Codec<T15> product15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Function15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> apply,
  Function1<T15, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> tupled,
) => tuple15(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
  codec10,
  codec11,
  codec12,
  codec13,
  codec14,
).xmap(apply.tupled, tupled);

product16() ​

Codec<T16>product16<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,T16Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,)apply,RecordFunction(T16)tupled,);
Implementation
dart
static Codec<T16>
product16<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Function16<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> apply,
  Function1<T16, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> tupled,
) => tuple16(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
  codec10,
  codec11,
  codec12,
  codec13,
  codec14,
  codec15,
).xmap(apply.tupled, tupled);

product17() ​

Codec<T17>product17<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,Codec<T16>codec16,T17Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,)apply,RecordFunction(T17)tupled,);
Implementation
dart
static Codec<T17>
product17<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Codec<T16> codec16,
  Function17<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
  apply,
  Function1<T17, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)>
  tupled,
) => tuple17(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
  codec10,
  codec11,
  codec12,
  codec13,
  codec14,
  codec15,
  codec16,
).xmap(apply.tupled, tupled);

product18() ​

Codec<T18>product18<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,Codec<T16>codec16,Codec<T17>codec17,T18Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,)apply,RecordFunction(T18)tupled,);
Implementation
dart
static Codec<T18>
product18<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Codec<T16> codec16,
  Codec<T17> codec17,
  Function18<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
  apply,
  Function1<T18, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)>
  tupled,
) => tuple18(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
  codec10,
  codec11,
  codec12,
  codec13,
  codec14,
  codec15,
  codec16,
  codec17,
).xmap(apply.tupled, tupled);

product19() ​

Codec<T19>product19<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,Codec<T16>codec16,Codec<T17>codec17,Codec<T18>codec18,T19Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,)apply,RecordFunction(T19)tupled,);
Implementation
dart
static Codec<T19> product19<
  T0,
  T1,
  T2,
  T3,
  T4,
  T5,
  T6,
  T7,
  T8,
  T9,
  T10,
  T11,
  T12,
  T13,
  T14,
  T15,
  T16,
  T17,
  T18,
  T19
>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Codec<T16> codec16,
  Codec<T17> codec17,
  Codec<T18> codec18,
  Function19<
    T0,
    T1,
    T2,
    T3,
    T4,
    T5,
    T6,
    T7,
    T8,
    T9,
    T10,
    T11,
    T12,
    T13,
    T14,
    T15,
    T16,
    T17,
    T18,
    T19
  >
  apply,
  Function1<
    T19,
    (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)
  >
  tupled,
) => tuple19(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
  codec10,
  codec11,
  codec12,
  codec13,
  codec14,
  codec15,
  codec16,
  codec17,
  codec18,
).xmap(apply.tupled, tupled);

product2() ​

Codec<T2>product2<T0, T1, T2>(Codec<T0>codec0,Codec<T1>codec1,T2Function(T0,T1)apply,RecordFunction(T2)tupled,);
Implementation
dart
static Codec<T2> product2<T0, T1, T2>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Function2<T0, T1, T2> apply,
  Function1<T2, (T0, T1)> tupled,
) => tuple2(codec0, codec1).xmap(apply.tupled, tupled);

product20() ​

Codec<T20>product20<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,Codec<T16>codec16,Codec<T17>codec17,Codec<T18>codec18,Codec<T19>codec19,T20Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,)apply,RecordFunction(T20)tupled,);
Implementation
dart
static Codec<T20> product20<
  T0,
  T1,
  T2,
  T3,
  T4,
  T5,
  T6,
  T7,
  T8,
  T9,
  T10,
  T11,
  T12,
  T13,
  T14,
  T15,
  T16,
  T17,
  T18,
  T19,
  T20
>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Codec<T16> codec16,
  Codec<T17> codec17,
  Codec<T18> codec18,
  Codec<T19> codec19,
  Function20<
    T0,
    T1,
    T2,
    T3,
    T4,
    T5,
    T6,
    T7,
    T8,
    T9,
    T10,
    T11,
    T12,
    T13,
    T14,
    T15,
    T16,
    T17,
    T18,
    T19,
    T20
  >
  apply,
  Function1<
    T20,
    (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)
  >
  tupled,
) => tuple20(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
  codec10,
  codec11,
  codec12,
  codec13,
  codec14,
  codec15,
  codec16,
  codec17,
  codec18,
  codec19,
).xmap(apply.tupled, tupled);

product21() ​

Codec<T21>product21<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,Codec<T16>codec16,Codec<T17>codec17,Codec<T18>codec18,Codec<T19>codec19,Codec<T20>codec20,T21Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,)apply,RecordFunction(T21)tupled,);
Implementation
dart
static Codec<T21> product21<
  T0,
  T1,
  T2,
  T3,
  T4,
  T5,
  T6,
  T7,
  T8,
  T9,
  T10,
  T11,
  T12,
  T13,
  T14,
  T15,
  T16,
  T17,
  T18,
  T19,
  T20,
  T21
>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Codec<T16> codec16,
  Codec<T17> codec17,
  Codec<T18> codec18,
  Codec<T19> codec19,
  Codec<T20> codec20,
  Function21<
    T0,
    T1,
    T2,
    T3,
    T4,
    T5,
    T6,
    T7,
    T8,
    T9,
    T10,
    T11,
    T12,
    T13,
    T14,
    T15,
    T16,
    T17,
    T18,
    T19,
    T20,
    T21
  >
  apply,
  Function1<
    T21,
    (
      T0,
      T1,
      T2,
      T3,
      T4,
      T5,
      T6,
      T7,
      T8,
      T9,
      T10,
      T11,
      T12,
      T13,
      T14,
      T15,
      T16,
      T17,
      T18,
      T19,
      T20,
    )
  >
  tupled,
) => tuple21(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
  codec10,
  codec11,
  codec12,
  codec13,
  codec14,
  codec15,
  codec16,
  codec17,
  codec18,
  codec19,
  codec20,
).xmap(apply.tupled, tupled);

product22() ​

Codec<T22>product22<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,Codec<T16>codec16,Codec<T17>codec17,Codec<T18>codec18,Codec<T19>codec19,Codec<T20>codec20,Codec<T21>codec21,T22Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,)apply,RecordFunction(T22)tupled,);
Implementation
dart
static Codec<T22> product22<
  T0,
  T1,
  T2,
  T3,
  T4,
  T5,
  T6,
  T7,
  T8,
  T9,
  T10,
  T11,
  T12,
  T13,
  T14,
  T15,
  T16,
  T17,
  T18,
  T19,
  T20,
  T21,
  T22
>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Codec<T16> codec16,
  Codec<T17> codec17,
  Codec<T18> codec18,
  Codec<T19> codec19,
  Codec<T20> codec20,
  Codec<T21> codec21,
  Function22<
    T0,
    T1,
    T2,
    T3,
    T4,
    T5,
    T6,
    T7,
    T8,
    T9,
    T10,
    T11,
    T12,
    T13,
    T14,
    T15,
    T16,
    T17,
    T18,
    T19,
    T20,
    T21,
    T22
  >
  apply,
  Function1<
    T22,
    (
      T0,
      T1,
      T2,
      T3,
      T4,
      T5,
      T6,
      T7,
      T8,
      T9,
      T10,
      T11,
      T12,
      T13,
      T14,
      T15,
      T16,
      T17,
      T18,
      T19,
      T20,
      T21,
    )
  >
  tupled,
) => tuple22(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
  codec9,
  codec10,
  codec11,
  codec12,
  codec13,
  codec14,
  codec15,
  codec16,
  codec17,
  codec18,
  codec19,
  codec20,
  codec21,
).xmap(apply.tupled, tupled);

product3() ​

Codec<T3>product3<T0, T1, T2, T3>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,T3Function(T0,T1,T2)apply,RecordFunction(T3)tupled,);
Implementation
dart
static Codec<T3> product3<T0, T1, T2, T3>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Function3<T0, T1, T2, T3> apply,
  Function1<T3, (T0, T1, T2)> tupled,
) => tuple3(codec0, codec1, codec2).xmap(apply.tupled, tupled);

product4() ​

Codec<T4>product4<T0, T1, T2, T3, T4>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,T4Function(T0,T1,T2,T3)apply,RecordFunction(T4)tupled,);
Implementation
dart
static Codec<T4> product4<T0, T1, T2, T3, T4>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Function4<T0, T1, T2, T3, T4> apply,
  Function1<T4, (T0, T1, T2, T3)> tupled,
) => tuple4(codec0, codec1, codec2, codec3).xmap(apply.tupled, tupled);

product5() ​

Codec<T5>product5<T0, T1, T2, T3, T4, T5>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,T5Function(T0,T1,T2,T3,T4)apply,RecordFunction(T5)tupled,);
Implementation
dart
static Codec<T5> product5<T0, T1, T2, T3, T4, T5>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Function5<T0, T1, T2, T3, T4, T5> apply,
  Function1<T5, (T0, T1, T2, T3, T4)> tupled,
) => tuple5(codec0, codec1, codec2, codec3, codec4).xmap(apply.tupled, tupled);

product6() ​

Codec<T6>product6<T0, T1, T2, T3, T4, T5, T6>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,T6Function(T0,T1,T2,T3,T4,T5)apply,RecordFunction(T6)tupled,);
Implementation
dart
static Codec<T6> product6<T0, T1, T2, T3, T4, T5, T6>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Function6<T0, T1, T2, T3, T4, T5, T6> apply,
  Function1<T6, (T0, T1, T2, T3, T4, T5)> tupled,
) => tuple6(codec0, codec1, codec2, codec3, codec4, codec5).xmap(apply.tupled, tupled);

product7() ​

Codec<T7>product7<T0, T1, T2, T3, T4, T5, T6, T7>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,T7Function(T0,T1,T2,T3,T4,T5,T6)apply,RecordFunction(T7)tupled,);
Implementation
dart
static Codec<T7> product7<T0, T1, T2, T3, T4, T5, T6, T7>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Function7<T0, T1, T2, T3, T4, T5, T6, T7> apply,
  Function1<T7, (T0, T1, T2, T3, T4, T5, T6)> tupled,
) => tuple7(codec0, codec1, codec2, codec3, codec4, codec5, codec6).xmap(apply.tupled, tupled);

product8() ​

Codec<T8>product8<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,T8Function(T0,T1,T2,T3,T4,T5,T6,T7)apply,RecordFunction(T8)tupled,);
Implementation
dart
static Codec<T8> product8<T0, T1, T2, T3, T4, T5, T6, T7, T8>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Function8<T0, T1, T2, T3, T4, T5, T6, T7, T8> apply,
  Function1<T8, (T0, T1, T2, T3, T4, T5, T6, T7)> tupled,
) => tuple8(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
).xmap(apply.tupled, tupled);

product9() ​

Codec<T9>product9<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,T9Function(T0,T1,T2,T3,T4,T5,T6,T7,T8,)apply,RecordFunction(T9)tupled,);
Implementation
dart
static Codec<T9> product9<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Function9<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> apply,
  Function1<T9, (T0, T1, T2, T3, T4, T5, T6, T7, T8)> tupled,
) => tuple9(
  codec0,
  codec1,
  codec2,
  codec3,
  codec4,
  codec5,
  codec6,
  codec7,
  codec8,
).xmap(apply.tupled, tupled);

provide() ​

Codec<A>provide<A>(Avalue)
Implementation
dart
static Codec<A> provide<A>(A value) => ProvideCodec(value);

tuple10() override ​

Codec<Record>tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,);

Encodes ten fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>
tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
) => Codec.of(
  Decoder.tuple10(codec0, codec1, codec2, codec3, codec4, codec5, codec6, codec7, codec8, codec9),
  Encoder.tuple10(codec0, codec1, codec2, codec3, codec4, codec5, codec6, codec7, codec8, codec9),
);

tuple11() override ​

Codec<Record>tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,);

Encodes eleven fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
) => Codec.of(
  Decoder.tuple11(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
  ),
  Encoder.tuple11(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
  ),
);

tuple12() override ​

Codec<Record>tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,);

Encodes twelve fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
) => Codec.of(
  Decoder.tuple12(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
  ),
  Encoder.tuple12(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
  ),
);

tuple13() override ​

Codec<Record>tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,);

Encodes thirteen fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>
tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
) => Codec.of(
  Decoder.tuple13(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
  ),
  Encoder.tuple13(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
  ),
);

tuple14() override ​

Codec<Record>tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,);

Encodes fourteen fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>
tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
) => Codec.of(
  Decoder.tuple14(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
  ),
  Encoder.tuple14(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
  ),
);

tuple15() override ​

Codec<Record>tuple15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,);

Encodes fifteen fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>
tuple15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
) => Codec.of(
  Decoder.tuple15(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
  ),
  Encoder.tuple15(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
  ),
);

tuple16() override ​

Codec<Record>tuple16<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,);

Encodes sixteen fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>
tuple16<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
) => Codec.of(
  Decoder.tuple16(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
  ),
  Encoder.tuple16(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
  ),
);

tuple17() override ​

Codec<Record>tuple17<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,Codec<T16>codec16,);

Encodes seventeen fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)>
tuple17<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Codec<T16> codec16,
) => Codec.of(
  Decoder.tuple17(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
    codec16,
  ),
  Encoder.tuple17(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
    codec16,
  ),
);

tuple18() override ​

Codec<Record>tuple18<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,Codec<T16>codec16,Codec<T17>codec17,);

Encodes eighteen fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)>
tuple18<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Codec<T16> codec16,
  Codec<T17> codec17,
) => Codec.of(
  Decoder.tuple18(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
    codec16,
    codec17,
  ),
  Encoder.tuple18(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
    codec16,
    codec17,
  ),
);

tuple19() override ​

Codec<Record>tuple19<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,Codec<T16>codec16,Codec<T17>codec17,Codec<T18>codec18,);

Encodes nineteen fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<
  (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)
>
tuple19<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Codec<T16> codec16,
  Codec<T17> codec17,
  Codec<T18> codec18,
) => Codec.of(
  Decoder.tuple19(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
    codec16,
    codec17,
    codec18,
  ),
  Encoder.tuple19(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
    codec16,
    codec17,
    codec18,
  ),
);

tuple2() override ​

Codec<Record>tuple2<T0, T1>(Codec<T0>codec0,Codec<T1>codec1)

Encodes two fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1)> tuple2<T0, T1>(
  Codec<T0> codec0,
  Codec<T1> codec1,
) => Codec.of(Decoder.tuple2(codec0, codec1), Encoder.tuple2(codec0, codec1));

tuple20() override ​

Codec<Record>tuple20<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,Codec<T16>codec16,Codec<T17>codec17,Codec<T18>codec18,Codec<T19>codec19,);

Encodes twenty fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<
  (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)
>
tuple20<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Codec<T16> codec16,
  Codec<T17> codec17,
  Codec<T18> codec18,
  Codec<T19> codec19,
) => Codec.of(
  Decoder.tuple20(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
    codec16,
    codec17,
    codec18,
    codec19,
  ),
  Encoder.tuple20(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
    codec16,
    codec17,
    codec18,
    codec19,
  ),
);

tuple21() override ​

Codec<Record>tuple21<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,Codec<T16>codec16,Codec<T17>codec17,Codec<T18>codec18,Codec<T19>codec19,Codec<T20>codec20,);

Encodes twenty-one fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<
  (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)
>
tuple21<
  T0,
  T1,
  T2,
  T3,
  T4,
  T5,
  T6,
  T7,
  T8,
  T9,
  T10,
  T11,
  T12,
  T13,
  T14,
  T15,
  T16,
  T17,
  T18,
  T19,
  T20
>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Codec<T16> codec16,
  Codec<T17> codec17,
  Codec<T18> codec18,
  Codec<T19> codec19,
  Codec<T20> codec20,
) => Codec.of(
  Decoder.tuple21(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
    codec16,
    codec17,
    codec18,
    codec19,
    codec20,
  ),
  Encoder.tuple21(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
    codec16,
    codec17,
    codec18,
    codec19,
    codec20,
  ),
);

tuple22() override ​

Codec<Record>tuple22<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,Codec<T9>codec9,Codec<T10>codec10,Codec<T11>codec11,Codec<T12>codec12,Codec<T13>codec13,Codec<T14>codec14,Codec<T15>codec15,Codec<T16>codec16,Codec<T17>codec17,Codec<T18>codec18,Codec<T19>codec19,Codec<T20>codec20,Codec<T21>codec21,);

Encodes twenty-two fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<
  (
    T0,
    T1,
    T2,
    T3,
    T4,
    T5,
    T6,
    T7,
    T8,
    T9,
    T10,
    T11,
    T12,
    T13,
    T14,
    T15,
    T16,
    T17,
    T18,
    T19,
    T20,
    T21,
  )
>
tuple22<
  T0,
  T1,
  T2,
  T3,
  T4,
  T5,
  T6,
  T7,
  T8,
  T9,
  T10,
  T11,
  T12,
  T13,
  T14,
  T15,
  T16,
  T17,
  T18,
  T19,
  T20,
  T21
>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
  Codec<T9> codec9,
  Codec<T10> codec10,
  Codec<T11> codec11,
  Codec<T12> codec12,
  Codec<T13> codec13,
  Codec<T14> codec14,
  Codec<T15> codec15,
  Codec<T16> codec16,
  Codec<T17> codec17,
  Codec<T18> codec18,
  Codec<T19> codec19,
  Codec<T20> codec20,
  Codec<T21> codec21,
) => Codec.of(
  Decoder.tuple22(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
    codec16,
    codec17,
    codec18,
    codec19,
    codec20,
    codec21,
  ),
  Encoder.tuple22(
    codec0,
    codec1,
    codec2,
    codec3,
    codec4,
    codec5,
    codec6,
    codec7,
    codec8,
    codec9,
    codec10,
    codec11,
    codec12,
    codec13,
    codec14,
    codec15,
    codec16,
    codec17,
    codec18,
    codec19,
    codec20,
    codec21,
  ),
);

tuple3() override ​

Codec<Record>tuple3<T0, T1, T2>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,);

Encodes three fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2)> tuple3<T0, T1, T2>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
) => Codec.of(Decoder.tuple3(codec0, codec1, codec2), Encoder.tuple3(codec0, codec1, codec2));

tuple4() override ​

Codec<Record>tuple4<T0, T1, T2, T3>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,);

Encodes four fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3)> tuple4<T0, T1, T2, T3>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
) => Codec.of(
  Decoder.tuple4(codec0, codec1, codec2, codec3),
  Encoder.tuple4(codec0, codec1, codec2, codec3),
);

tuple5() override ​

Codec<Record>tuple5<T0, T1, T2, T3, T4>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,);

Encodes five fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4)> tuple5<T0, T1, T2, T3, T4>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
) => Codec.of(
  Decoder.tuple5(codec0, codec1, codec2, codec3, codec4),
  Encoder.tuple5(codec0, codec1, codec2, codec3, codec4),
);

tuple6() override ​

Codec<Record>tuple6<T0, T1, T2, T3, T4, T5>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,);

Encodes six fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5)> tuple6<T0, T1, T2, T3, T4, T5>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
) => Codec.of(
  Decoder.tuple6(codec0, codec1, codec2, codec3, codec4, codec5),
  Encoder.tuple6(codec0, codec1, codec2, codec3, codec4, codec5),
);

tuple7() override ​

Codec<Record>tuple7<T0, T1, T2, T3, T4, T5, T6>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,);

Encodes seven fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5, T6)> tuple7<T0, T1, T2, T3, T4, T5, T6>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
) => Codec.of(
  Decoder.tuple7(codec0, codec1, codec2, codec3, codec4, codec5, codec6),
  Encoder.tuple7(codec0, codec1, codec2, codec3, codec4, codec5, codec6),
);

tuple8() override ​

Codec<Record>tuple8<T0, T1, T2, T3, T4, T5, T6, T7>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,);

Encodes eight fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5, T6, T7)> tuple8<T0, T1, T2, T3, T4, T5, T6, T7>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
) => Codec.of(
  Decoder.tuple8(codec0, codec1, codec2, codec3, codec4, codec5, codec6, codec7),
  Encoder.tuple8(codec0, codec1, codec2, codec3, codec4, codec5, codec6, codec7),
);

tuple9() override ​

Codec<Record>tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Codec<T0>codec0,Codec<T1>codec1,Codec<T2>codec2,Codec<T3>codec3,Codec<T4>codec4,Codec<T5>codec5,Codec<T6>codec6,Codec<T7>codec7,Codec<T8>codec8,);

Encodes nine fields sequentially, concatenating the resulting bits.

Implementation
dart
static Codec<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8>(
  Codec<T0> codec0,
  Codec<T1> codec1,
  Codec<T2> codec2,
  Codec<T3> codec3,
  Codec<T4> codec4,
  Codec<T5> codec5,
  Codec<T6> codec6,
  Codec<T7> codec7,
  Codec<T8> codec8,
) => Codec.of(
  Decoder.tuple9(codec0, codec1, codec2, codec3, codec4, codec5, codec6, codec7, codec8),
  Encoder.tuple9(codec0, codec1, codec2, codec3, codec4, codec5, codec6, codec7, codec8),
);

uinteger() ​

Codec<int>uinteger(intsize)
Implementation
dart
static Codec<int> uinteger(int size) => IntCodec(size, false, Endian.big);

uintegerL() ​

Codec<int>uintegerL(intsize)
Implementation
dart
static Codec<int> uintegerL(int size) => IntCodec(size, false, Endian.little);

variableSized() ​

Codec<A>variableSized<A>(Codec<int>sizeCodec,Codec<A>valueCodec)
Implementation
dart
static Codec<A> variableSized<A>(
  Codec<int> sizeCodec,
  Codec<A> valueCodec,
) => VariableSizedCodec(sizeCodec, valueCodec);

xmapped() ​

Codec<B>xmapped<A, B>(Codec<A>by,IMap<A,B>cases)
Implementation
dart
static Codec<B> xmapped<A, B>(Codec<A> by, IMap<A, B> cases) => XMappedCodec(by, cases);