Module CConv.EncodeSource

Sourcetype 'a output = {
  1. unit : 'a;
  2. bool : bool -> 'a;
  3. float : float -> 'a;
  4. char : char -> 'a;
  5. int : int -> 'a;
  6. nativeint : nativeint -> 'a;
  7. int32 : int32 -> 'a;
  8. int64 : int64 -> 'a;
  9. string : string -> 'a;
  10. list : 'a list -> 'a;
  11. option : 'a option -> 'a;
  12. record : (string * 'a) list -> 'a;
  13. tuple : 'a list -> 'a;
  14. sum : string -> 'a list -> 'a;
}
Sourceval string_target : string output

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

Sourcetype -'src encoder = {
  1. emit : 'into. 'into output -> 'src -> 'into;
}

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

Sourceval unit : unit encoder
Sourceval bool : bool encoder
Sourceval float : float encoder
Sourceval char : char encoder
Sourceval int : int encoder
Sourceval nativeint : nativeint encoder
Sourceval int32 : int32 encoder
Sourceval int64 : int64 encoder
Sourceval string : string encoder
Sourceval list : 'a encoder -> 'a list encoder
Sourceval option : 'a encoder -> 'a option encoder
Sourceval map : ('a -> 'b) -> 'b encoder -> 'a encoder
Sourceval array : 'a encoder -> 'a array encoder
Sourceval sequence : 'a encoder -> 'a sequence encoder
Composite Types
Sourceval apply : 'into output -> 'src encoder -> 'src -> 'into

Helper to apply an encoder to a value

Sourcetype 'r record_encoder = {
  1. record_emit : 'into. 'into output -> 'r -> (string * 'into) list;
}
Sourceval record : 'r record_encoder -> 'r encoder

Encode a record, using the polymorphic record record_encoder to generate an association list

Sourceval record_fix : ('r encoder -> 'r record_encoder) -> 'r encoder

Fixpoint on record definition

Example:

 type point = {x:int; y:int; c:string};;
 let enc_point = record
   {record_emit=fun into {x;y;c} ->
      [ "x", into.int x
      ; "y", into.int y
      ; "c", into.string c
      ]
  } ;;
Sourcetype 't tuple_encoder = {
  1. tuple_emit : 'into. 'into output -> 't -> 'into list;
}
Sourceval tuple : 'a tuple_encoder -> 'a encoder

General encoding of tuples (returns a list of values)

Sourceval pair : 'a encoder -> 'b encoder -> ('a * 'b) encoder
Sourceval triple : 'a encoder -> 'b encoder -> 'c encoder -> ('a * 'b * 'c) encoder
Sourceval quad : 'a encoder -> 'b encoder -> 'c encoder -> 'd encoder -> ('a * 'b * 'c * 'd) encoder
Sourcetype 's sum_encoder = {
  1. sum_emit : 'into. 'into output -> 's -> string * 'into list;
}
Sourceval sum : 'a sum_encoder -> 'a encoder
Sourceval sum0 : ('a -> string) -> 'a encoder

Constant sums, only put the name

Sourceval sum_fix : ('a encoder -> 'a sum_encoder) -> 'a encoder

Fixpoint on sum types

Example:

 type tree = Empty | Leaf of int | Node of tree * tree;;
let encode_tree = sum_fix
  (fun self -> {sum_emit=fun into x -> match x with
    | Empty -> "empty", []
    | Leaf i -> "leaf", [int.emit into i]
    | Node (l,r) -> "node", [self.emit into l; self.emit into r]
  });;