Identity encoder selector against field indices (helpful for defining empty record type encoders).

Identity encoder selector factory against tag indices (helpful for defining “empty sum type” encoders, i.e. sum types that none of their constructors carry values).

Initiate an encoder.

Returns the encoded bytes so far, ignoring the current byte.

Assumes given ByteArray is a single byte.

Helper for making encoders for record types with 2 fields. More performant than using make_rec.

Helper for making encoders for record types with 3 fields. More performant than using make_rec.

Helper for making encoders for record types with 4 fields. More performant than using make_rec.

Helper for creating record type encoders. The resulting encoder traverses a list of Data values and uses their indices to find their corresponding encoders from the provided selector function.

Helper for making encoders for sum types with 2 data constructors, and arbitrary fields in each. More performant than using make_sum. The Data in return type is assumed to be a Constr.

Helper for making encoders for sum types with 3 data constructors, and arbitrary fields in each. More performant than using make_sum. The Data in return type is assumed to be a Constr.

Helper for making encoders for sum types with 4 data constructors, and arbitrary fields in each. More performant than using make_sum. The Data in return type is assumed to be a Constr.

Helper function for generating encoders for sum types. The factory is expected to be a function that takes an index, which is the index of the constructor in the subject sum type, and returns another function that given the index of a field from the record, returns an encoder function.

An example can be:

pub type Color {
  Abyss
  BlackAndWhite {
    white: Int,
  }
  Colored {
    red: Int,
    green: Int,
    blue: Int,
  }
}

The factory function for this datatype should be:

let color_encoder_factory =
  fn(tag: Int) {
    if tag == 0 {
      identity_encoder_fn_selector
    } else if tag == 1 {
      fn(f_index: Int) {
        if f_index == 0 {
          integer |> contramap(builtin.un_i_data)
        } else {
          fail
        }
      }
    } else if tag == 2 {
      fn(f_index: Int) {
        if f_index <= 2 {
          integer |> contramap(builtin.un_i_data)
        } else {
          fail
        }
      }
    } else {
      fail
    }
  }

In this case, it can be much simpler if we forgo the strictness:

let color_encoder_factory =
  fn(_) {
    fn(_) {
      integer |> contramap(builtin.un_i_data)
    }
  }

And the encoder itself will be:

let color_encoder = make_sum(3, color_encoder_factory)