distribute - v4.0.0

distribute/codec/tagged

Types

TaggedMessage

opaque </>

A message annotated with a protocol tag and version.

pub opaque type TaggedMessage(payload)

Values

codec

</> 
pub fn codec(
  expected_tag: String,
  expected_version: Int,
  payload_codec: codec.Codec(payload),
) -> codec.Codec(TaggedMessage(payload))

Bundled Codec for tagged messages.

let tagged_int = tagged.codec("counter", 1, codec.int())

decode_tagged

</> 
pub fn decode_tagged(
  expected_tag: String,
  expected_version: Int,
  payload_decoder: fn(BitArray) -> Result(
    payload,
    codec.DecodeError,
  ),
  data: BitArray,
) -> Result(payload, codec.DecodeError)

Convenience: decode binary as a tagged message and extract the payload.

decoder

</> 
pub fn decoder(
  expected_tag: String,
  expected_version: Int,
  payload_decoder: fn(BitArray) -> Result(
    payload,
    codec.DecodeError,
  ),
) -> fn(BitArray) -> Result(
  TaggedMessage(payload),
  codec.DecodeError,
)

Decoder for tagged messages with tag and version validation.

encode_tagged

</> 
pub fn encode_tagged(
  tag: String,
  version: Int,
  payload_encoder: fn(payload) -> Result(
    BitArray,
    codec.EncodeError,
  ),
  value: payload,
) -> Result(BitArray, codec.EncodeError)

Convenience: encode a value as a tagged message in one step.

encoder

</> 
pub fn encoder(
  payload_encoder: fn(payload) -> Result(
    BitArray,
    codec.EncodeError,
  ),
) -> fn(TaggedMessage(payload)) -> Result(
  BitArray,
  codec.EncodeError,
)

Encoder for tagged messages.

Format: [tag_len:32][tag:utf8][version:32][payload]

Rejects values that would silently wrap when written to the fixed-width 32-bit fields:

  • version must be in [0, 2^32 - 1]
  • tag byte-length must be in [0, 2^32 - 1] (a 4 GiB tag is absurd in practice but the bound is enforced for defence in depth)

new

</> 
pub fn new(
  tag: String,
  version: Int,
  payload: payload,
) -> TaggedMessage(payload)

Create a tagged message.

payload

</> 
pub fn payload(msg: TaggedMessage(payload)) -> payload

Extract the payload.

sized_decoder

</> 
pub fn sized_decoder(
  expected_tag: String,
  expected_version: Int,
  payload_sized_decoder: fn(BitArray) -> Result(
    #(payload, BitArray),
    codec.DecodeError,
  ),
) -> fn(BitArray) -> Result(
  #(TaggedMessage(payload), BitArray),
  codec.DecodeError,
)

Sized decoder for tagged messages with tag and version validation.

Returns TagMismatch or VersionMismatch errors for protocol mismatches. Unlike decoder, returns remaining bytes for use in composite codecs.

tag

</> 
pub fn tag(msg: TaggedMessage(payload)) -> String

Get the tag.

version

</> 
pub fn version(msg: TaggedMessage(payload)) -> Int

Get the version.

✨ Search Document