package cconv

  1. Overview
  2. Docs
On This Page
  1. Composite Types

Module CConv.Encode

type 'a target = {
  1. unit : 'a;
  2. bool : bool -> 'a;
  3. float : float -> 'a;
  4. int : int -> 'a;
  5. string : string -> 'a;
  6. list : 'a list -> 'a;
  7. option : 'a option -> 'a;
  8. record : (string * 'a) list -> 'a;
  9. tuple : 'a list -> 'a;
  10. sum : string -> 'a list -> 'a;
}
val string_target : string target

Print values. Caution, inefficient! Should be used for debugging only

type -'src encoder = {
  1. emit : 'into. 'into target -> 'src -> 'into;
}

A way to encode values of type 'src into any serialization format

val unit : unit encoder
val bool : bool encoder
val float : float encoder
val int : int encoder
val string : string encoder
val list : 'a encoder -> 'a list encoder
val map : ('a -> 'b) -> 'b encoder -> 'a encoder
val array : 'a encoder -> 'a array encoder
val sequence : 'a encoder -> 'a sequence encoder
type hlist =
  1. | HNil : hlist
  2. | HCons : 'a encoder * 'a * hlist -> hlist

Heterogeneous List

val hnil : hlist
val hcons : 'a encoder -> 'a -> hlist -> hlist
val (@::) : ('a encoder * 'a) -> hlist -> hlist
Composite Types
type record_fields =
  1. | RecordEnd : record_fields
    (*

    Empty record

    *)
  2. | RecordField : string * 'a encoder * 'a * record_fields -> record_fields
val record_end : record_fields
val field : string -> 'a encoder -> 'a -> record_fields -> record_fields
val (@->) : (string * 'a encoder * 'a) -> record_fields -> record_fields

Infix constructor for record fields. Example:

 type point = {x:int; y:int; c:string};;
 let enc_point = record
   (fun {x;y;c} ->
      ("x", int, x) @->
      ("y", int, y) @->
      ("c", string, c) @->
      record_end
   ) ;;
val record : ('r -> record_fields) -> 'r encoder
val record_fix : ('r encoder -> 'r -> record_fields) -> 'r encoder
val tuple : ('a -> hlist) -> 'a encoder

General encoding of tuples

val pair : 'a encoder -> 'b encoder -> ('a * 'b) encoder
val triple : 'a encoder -> 'b encoder -> 'c encoder -> ('a * 'b * 'c) encoder
val quad : 'a encoder -> 'b encoder -> 'c encoder -> 'd encoder -> ('a * 'b * 'c * 'd) encoder
val sum : ('a -> string * hlist) -> 'a encoder
val sum0 : ('a -> string) -> 'a encoder

Constant sums

val sum_fix : ('a encoder -> 'a -> string * hlist) -> 'a encoder
val option : 'a encoder -> 'a option encoder