Up  Next

Module CConv.Encode

module Encode: sig .. end
type 'a output = {
   unit : 'a;
   bool : bool -> 'a;
   float : float -> 'a;
   char : char -> 'a;
   int : int -> 'a;
   nativeint : nativeint -> 'a;
   int32 : int32 -> 'a;
   int64 : int64 -> 'a;
   string : string -> 'a;
   list : 'a list -> 'a;
   option : 'a option -> 'a;
   record : (string * 'a) list -> 'a;
   tuple : 'a list -> 'a;
   sum : string -> 'a list -> 'a;
} 
val string_target : string output

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

type 'src encoder = {
   emit : 'into. 'into output -> '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 char : char encoder
val int : int encoder
val nativeint : nativeint encoder
val int32 : int32 encoder
val int64 : int64 encoder
val string : string encoder
val list : 'a encoder -> 'a list encoder
val option : 'a encoder -> 'a option encoder
val map : ('a -> 'b) -> 'b encoder -> 'a encoder
val array : 'a encoder -> 'a array encoder
val sequence : 'a encoder -> 'a CConv.sequence encoder
Composite Types 
val apply : 'into output -> 'src encoder -> 'src -> 'into

Helper to apply an encoder to a value

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

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

val 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
        ]
    } ;;
  
type 't tuple_encoder = {
   tuple_emit : 'into. 'into output -> 't -> 'into list;
} 
val tuple : 'a tuple_encoder -> 'a encoder

General encoding of tuples (returns a list of values)

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
type 's sum_encoder = {
   sum_emit : 'into. 'into output -> 's -> string * 'into list;
} 
val sum : 'a sum_encoder -> 'a encoder
val sum0 : ('a -> string) -> 'a encoder

Constant sums, only put the name

val 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]
    });;
  
val option : 'a encoder -> 'a option encoder