distribute - v3.0.0

distribute/codec/composite

Values

option

</> 
pub fn option(
  inner: codec.Codec(a),
) -> codec.Codec(option.Option(a))

option_decoder

</> 
pub fn option_decoder(
  inner: fn(BitArray) -> Result(a, codec.DecodeError),
) -> fn(BitArray) -> Result(option.Option(a), codec.DecodeError)

option_encoder

</> 
pub fn option_encoder(
  inner: fn(a) -> Result(BitArray, codec.EncodeError),
) -> fn(option.Option(a)) -> Result(BitArray, codec.EncodeError)

Encoder for Option(a). None → <<0>>, Some(v) → <<1, encoded_v>>.

option_sized_decoder

</> 
pub fn option_sized_decoder(
  inner: fn(BitArray) -> Result(#(a, BitArray), codec.DecodeError),
) -> fn(BitArray) -> Result(
  #(option.Option(a), BitArray),
  codec.DecodeError,
)

result_decoder

</> 
pub fn result_decoder(
  ok_decoder: fn(BitArray) -> Result(a, codec.DecodeError),
  error_decoder: fn(BitArray) -> Result(e, codec.DecodeError),
) -> fn(BitArray) -> Result(Result(a, e), codec.DecodeError)

result_encoder

</> 
pub fn result_encoder(
  ok_encoder: fn(a) -> Result(BitArray, codec.EncodeError),
  error_encoder: fn(e) -> Result(BitArray, codec.EncodeError),
) -> fn(Result(a, e)) -> Result(BitArray, codec.EncodeError)

Encoder for Result(a, e). Ok → <<0, encoded>>, Error → <<1, encoded>>.

result_sized_decoder

</> 
pub fn result_sized_decoder(
  ok_decoder: fn(BitArray) -> Result(
    #(a, BitArray),
    codec.DecodeError,
  ),
  error_decoder: fn(BitArray) -> Result(
    #(e, BitArray),
    codec.DecodeError,
  ),
) -> fn(BitArray) -> Result(
  #(Result(a, e), BitArray),
  codec.DecodeError,
)

tuple2

</> 
pub fn tuple2(
  first: codec.Codec(a),
  second: codec.Codec(b),
) -> codec.Codec(#(a, b))

tuple2_decoder

</> 
pub fn tuple2_decoder(
  first: fn(BitArray) -> Result(#(a, BitArray), codec.DecodeError),
  second: fn(BitArray) -> Result(
    #(b, BitArray),
    codec.DecodeError,
  ),
) -> fn(BitArray) -> Result(#(a, b), codec.DecodeError)

tuple2_encoder

</> 
pub fn tuple2_encoder(
  first: fn(a) -> Result(BitArray, codec.EncodeError),
  second: fn(b) -> Result(BitArray, codec.EncodeError),
) -> fn(#(a, b)) -> Result(BitArray, codec.EncodeError)

Encoder for #(a, b). First element is length-prefixed (32-bit).

tuple2_sized_decoder

</> 
pub fn tuple2_sized_decoder(
  first: fn(BitArray) -> Result(#(a, BitArray), codec.DecodeError),
  second: fn(BitArray) -> Result(
    #(b, BitArray),
    codec.DecodeError,
  ),
) -> fn(BitArray) -> Result(
  #(#(a, b), BitArray),
  codec.DecodeError,
)

tuple3

</> 
pub fn tuple3(
  first: codec.Codec(a),
  second: codec.Codec(b),
  third: codec.Codec(c),
) -> codec.Codec(#(a, b, c))

tuple3_decoder

</> 
pub fn tuple3_decoder(
  first: fn(BitArray) -> Result(#(a, BitArray), codec.DecodeError),
  second: fn(BitArray) -> Result(
    #(b, BitArray),
    codec.DecodeError,
  ),
  third: fn(BitArray) -> Result(#(c, BitArray), codec.DecodeError),
) -> fn(BitArray) -> Result(#(a, b, c), codec.DecodeError)

tuple3_encoder

</> 
pub fn tuple3_encoder(
  first: fn(a) -> Result(BitArray, codec.EncodeError),
  second: fn(b) -> Result(BitArray, codec.EncodeError),
  third: fn(c) -> Result(BitArray, codec.EncodeError),
) -> fn(#(a, b, c)) -> Result(BitArray, codec.EncodeError)

Encoder for #(a, b, c). First two elements are length-prefixed (32-bit).

tuple3_sized_decoder

</> 
pub fn tuple3_sized_decoder(
  first: fn(BitArray) -> Result(#(a, BitArray), codec.DecodeError),
  second: fn(BitArray) -> Result(
    #(b, BitArray),
    codec.DecodeError,
  ),
  third: fn(BitArray) -> Result(#(c, BitArray), codec.DecodeError),
) -> fn(BitArray) -> Result(
  #(#(a, b, c), BitArray),
  codec.DecodeError,
)
✨ Search Document