sig
  type id
  module Repr :
    sig
      type t
      val make : ?constructor:int -> Pickle.id list -> Pickle.Repr.t
    end
  module Write :
    sig
      type s
      type +'a m
      val return : '-> 'a m
      val fail : string -> 'a m
      val ( >>= ) : 'a m -> ('-> 'b m) -> 'b m
      val ( >> ) : 'a m -> 'b m -> 'b m
      val liftM : ('-> 'b) -> 'a m -> 'b m
      val liftM2 : ('-> '-> 'c) -> 'a m -> 'b m -> 'c m
      val liftM3 : ('-> '-> '-> 'd) -> 'a m -> 'b m -> 'c m -> 'd m
      val liftM4 :
        ('-> '-> '-> '-> 'e) -> 'a m -> 'b m -> 'c m -> 'd m -> 'e m
      val liftM5 :
        ('-> '-> '-> '-> '-> 'f) ->
        'a m -> 'b m -> 'c m -> 'd m -> 'e m -> 'f m
      val ap : ('-> 'b) m -> 'a m -> 'b m
      val sequence : 'a m list -> 'a list m
      val sequence_ : 'a m list -> unit m
      val mapM : ('-> 'b m) -> 'a list -> 'b list m
      val mapM_ : ('-> 'b m) -> 'a list -> unit m
      val ( =<< ) : ('-> 'b m) -> 'a m -> 'b m
      val join : 'a m m -> 'a m
      val filterM : ('-> bool m) -> 'a list -> 'a list m
      val mapAndUnzipM :
        ('-> ('b * 'c) m) -> 'a list -> ('b list * 'c list) m
      val zipWithM : ('-> '-> 'c m) -> 'a list -> 'b list -> 'c list m
      val zipWithM_ : ('-> '-> 'c m) -> 'a list -> 'b list -> unit m
      val foldM : ('-> '-> 'a m) -> '-> 'b list -> 'a m
      val foldM_ : ('-> '-> 'a m) -> '-> 'b list -> unit m
      val replicateM : int -> 'a m -> 'a list m
      val replicateM_ : int -> 'a m -> unit m
      val quand : bool -> unit m -> unit m
      val unless : bool -> unit m -> unit m
      type state = s
      val get : state m
      val put : state -> unit m
      val runState : 'a m -> state -> 'a * state
      module Utils :
        functor
          (T : Typeable.Typeable) (E : sig
                                         type a = T.a
                                         val eq : a -> a -> bool
                                       end->
          sig
            val allocate : T.a -> (Pickle.id -> unit m) -> Pickle.id m
            val store_repr : Pickle.id -> Pickle.Repr.t -> unit m
          end
    end
  module Read :
    sig
      type s
      type +'a m
      val return : '-> 'a m
      val fail : string -> 'a m
      val ( >>= ) : 'a m -> ('-> 'b m) -> 'b m
      val ( >> ) : 'a m -> 'b m -> 'b m
      val liftM : ('-> 'b) -> 'a m -> 'b m
      val liftM2 : ('-> '-> 'c) -> 'a m -> 'b m -> 'c m
      val liftM3 : ('-> '-> '-> 'd) -> 'a m -> 'b m -> 'c m -> 'd m
      val liftM4 :
        ('-> '-> '-> '-> 'e) -> 'a m -> 'b m -> 'c m -> 'd m -> 'e m
      val liftM5 :
        ('-> '-> '-> '-> '-> 'f) ->
        'a m -> 'b m -> 'c m -> 'd m -> 'e m -> 'f m
      val ap : ('-> 'b) m -> 'a m -> 'b m
      val sequence : 'a m list -> 'a list m
      val sequence_ : 'a m list -> unit m
      val mapM : ('-> 'b m) -> 'a list -> 'b list m
      val mapM_ : ('-> 'b m) -> 'a list -> unit m
      val ( =<< ) : ('-> 'b m) -> 'a m -> 'b m
      val join : 'a m m -> 'a m
      val filterM : ('-> bool m) -> 'a list -> 'a list m
      val mapAndUnzipM :
        ('-> ('b * 'c) m) -> 'a list -> ('b list * 'c list) m
      val zipWithM : ('-> '-> 'c m) -> 'a list -> 'b list -> 'c list m
      val zipWithM_ : ('-> '-> 'c m) -> 'a list -> 'b list -> unit m
      val foldM : ('-> '-> 'a m) -> '-> 'b list -> 'a m
      val foldM_ : ('-> '-> 'a m) -> '-> 'b list -> unit m
      val replicateM : int -> 'a m -> 'a list m
      val replicateM_ : int -> 'a m -> unit m
      val quand : bool -> unit m -> unit m
      val unless : bool -> unit m -> unit m
      type state = s
      val get : state m
      val put : state -> unit m
      val runState : 'a m -> state -> 'a * state
      module Utils :
        functor (T : Typeable.Typeable->
          sig
            val sum : (int * Pickle.id list -> T.a m) -> Pickle.id -> T.a m
            val tuple : (Pickle.id list -> T.a m) -> Pickle.id -> T.a m
            val record :
              (T.a -> Pickle.id list -> T.a m) -> int -> Pickle.id -> T.a m
          end
    end
  exception UnpicklingError of string
  exception UnknownTag of int * string
  module type Pickle =
    sig
      type a
      module T :
        sig
          type a = a
          val type_rep : unit -> Typeable.TypeRep.t
          val has_type : Typeable.dynamic -> bool
          val cast : Typeable.dynamic -> a option
          val throwing_cast : Typeable.dynamic -> a
          val make_dynamic : a -> Typeable.dynamic
          val mk : a -> Typeable.dynamic
        end
      module E : sig type a = a val eq : a -> a -> bool end
      val pickle : Pickle.Pickle.a -> Pickle.id Pickle.Write.m
      val unpickle : Pickle.id -> Pickle.Pickle.a Pickle.Read.m
      val to_buffer : Buffer.t -> Pickle.Pickle.a -> unit
      val to_string : Pickle.Pickle.a -> string
      val to_channel : Pervasives.out_channel -> Pickle.Pickle.a -> unit
      val from_stream : char Stream.t -> Pickle.Pickle.a
      val from_string : string -> Pickle.Pickle.a
      val from_channel : Pervasives.in_channel -> Pickle.Pickle.a
    end
  module Defaults :
    functor
      (S : sig
             type a
             module T :
               sig
                 type a = a
                 val type_rep : unit -> Typeable.TypeRep.t
                 val has_type : Typeable.dynamic -> bool
                 val cast : Typeable.dynamic -> a option
                 val throwing_cast : Typeable.dynamic -> a
                 val make_dynamic : a -> Typeable.dynamic
                 val mk : a -> Typeable.dynamic
               end
             module E : sig type a = a val eq : a -> a -> bool end
             val pickle : Pickle.Defaults.a -> Pickle.id Pickle.Write.m
             val unpickle : Pickle.id -> Pickle.Defaults.a Pickle.Read.m
           end->
      sig
        type a = S.a
        module T :
          sig
            type a = a
            val type_rep : unit -> Typeable.TypeRep.t
            val has_type : Typeable.dynamic -> bool
            val cast : Typeable.dynamic -> a option
            val throwing_cast : Typeable.dynamic -> a
            val make_dynamic : a -> Typeable.dynamic
            val mk : a -> Typeable.dynamic
          end
        module E : sig type a = a val eq : a -> a -> bool end
        val pickle : a -> id Write.m
        val unpickle : id -> a Read.m
        val to_buffer : Buffer.t -> a -> unit
        val to_string : a -> string
        val to_channel : out_channel -> a -> unit
        val from_stream : char Stream.t -> a
        val from_string : string -> a
        val from_channel : in_channel -> a
      end
  module Pickle_unit :
    sig
      type a = unit
      module T :
        sig
          type a = a
          val type_rep : unit -> Typeable.TypeRep.t
          val has_type : Typeable.dynamic -> bool
          val cast : Typeable.dynamic -> a option
          val throwing_cast : Typeable.dynamic -> a
          val make_dynamic : a -> Typeable.dynamic
          val mk : a -> Typeable.dynamic
        end
      module E : sig type a = a val eq : a -> a -> bool end
      val pickle : a -> id Write.m
      val unpickle : id -> a Read.m
      val to_buffer : Buffer.t -> a -> unit
      val to_string : a -> string
      val to_channel : out_channel -> a -> unit
      val from_stream : char Stream.t -> a
      val from_string : string -> a
      val from_channel : in_channel -> a
    end
  module Pickle_bool :
    sig
      type a = bool
      module T :
        sig
          type a = a
          val type_rep : unit -> Typeable.TypeRep.t
          val has_type : Typeable.dynamic -> bool
          val cast : Typeable.dynamic -> a option
          val throwing_cast : Typeable.dynamic -> a
          val make_dynamic : a -> Typeable.dynamic
          val mk : a -> Typeable.dynamic
        end
      module E : sig type a = a val eq : a -> a -> bool end
      val pickle : a -> id Write.m
      val unpickle : id -> a Read.m
      val to_buffer : Buffer.t -> a -> unit
      val to_string : a -> string
      val to_channel : out_channel -> a -> unit
      val from_stream : char Stream.t -> a
      val from_string : string -> a
      val from_channel : in_channel -> a
    end
  module Pickle_int :
    sig
      type a = int
      module T :
        sig
          type a = a
          val type_rep : unit -> Typeable.TypeRep.t
          val has_type : Typeable.dynamic -> bool
          val cast : Typeable.dynamic -> a option
          val throwing_cast : Typeable.dynamic -> a
          val make_dynamic : a -> Typeable.dynamic
          val mk : a -> Typeable.dynamic
        end
      module E : sig type a = a val eq : a -> a -> bool end
      val pickle : a -> id Write.m
      val unpickle : id -> a Read.m
      val to_buffer : Buffer.t -> a -> unit
      val to_string : a -> string
      val to_channel : out_channel -> a -> unit
      val from_stream : char Stream.t -> a
      val from_string : string -> a
      val from_channel : in_channel -> a
    end
  module Pickle_char :
    sig
      type a = char
      module T :
        sig
          type a = a
          val type_rep : unit -> Typeable.TypeRep.t
          val has_type : Typeable.dynamic -> bool
          val cast : Typeable.dynamic -> a option
          val throwing_cast : Typeable.dynamic -> a
          val make_dynamic : a -> Typeable.dynamic
          val mk : a -> Typeable.dynamic
        end
      module E : sig type a = a val eq : a -> a -> bool end
      val pickle : a -> id Write.m
      val unpickle : id -> a Read.m
      val to_buffer : Buffer.t -> a -> unit
      val to_string : a -> string
      val to_channel : out_channel -> a -> unit
      val from_stream : char Stream.t -> a
      val from_string : string -> a
      val from_channel : in_channel -> a
    end
  module Pickle_float :
    sig
      type a = float
      module T :
        sig
          type a = a
          val type_rep : unit -> Typeable.TypeRep.t
          val has_type : Typeable.dynamic -> bool
          val cast : Typeable.dynamic -> a option
          val throwing_cast : Typeable.dynamic -> a
          val make_dynamic : a -> Typeable.dynamic
          val mk : a -> Typeable.dynamic
        end
      module E : sig type a = a val eq : a -> a -> bool end
      val pickle : a -> id Write.m
      val unpickle : id -> a Read.m
      val to_buffer : Buffer.t -> a -> unit
      val to_string : a -> string
      val to_channel : out_channel -> a -> unit
      val from_stream : char Stream.t -> a
      val from_string : string -> a
      val from_channel : in_channel -> a
    end
  module Pickle_num :
    sig
      type a = Num.num
      module T :
        sig
          type a = a
          val type_rep : unit -> Typeable.TypeRep.t
          val has_type : Typeable.dynamic -> bool
          val cast : Typeable.dynamic -> a option
          val throwing_cast : Typeable.dynamic -> a
          val make_dynamic : a -> Typeable.dynamic
          val mk : a -> Typeable.dynamic
        end
      module E : sig type a = a val eq : a -> a -> bool end
      val pickle : a -> id Write.m
      val unpickle : id -> a Read.m
      val to_buffer : Buffer.t -> a -> unit
      val to_string : a -> string
      val to_channel : out_channel -> a -> unit
      val from_stream : char Stream.t -> a
      val from_string : string -> a
      val from_channel : in_channel -> a
    end
  module Pickle_string :
    sig
      type a = string
      module T :
        sig
          type a = a
          val type_rep : unit -> Typeable.TypeRep.t
          val has_type : Typeable.dynamic -> bool
          val cast : Typeable.dynamic -> a option
          val throwing_cast : Typeable.dynamic -> a
          val make_dynamic : a -> Typeable.dynamic
          val mk : a -> Typeable.dynamic
        end
      module E : sig type a = a val eq : a -> a -> bool end
      val pickle : a -> id Write.m
      val unpickle : id -> a Read.m
      val to_buffer : Buffer.t -> a -> unit
      val to_string : a -> string
      val to_channel : out_channel -> a -> unit
      val from_stream : char Stream.t -> a
      val from_string : string -> a
      val from_channel : in_channel -> a
    end
  module Pickle_option :
    functor (V0 : Pickle->
      sig
        type a = V0.a option
        module T :
          sig
            type a = a
            val type_rep : unit -> Typeable.TypeRep.t
            val has_type : Typeable.dynamic -> bool
            val cast : Typeable.dynamic -> a option
            val throwing_cast : Typeable.dynamic -> a
            val make_dynamic : a -> Typeable.dynamic
            val mk : a -> Typeable.dynamic
          end
        module E : sig type a = a val eq : a -> a -> bool end
        val pickle : a -> id Write.m
        val unpickle : id -> a Read.m
        val to_buffer : Buffer.t -> a -> unit
        val to_string : a -> string
        val to_channel : out_channel -> a -> unit
        val from_stream : char Stream.t -> a
        val from_string : string -> a
        val from_channel : in_channel -> a
      end
  module Pickle_list :
    functor (V0 : Pickle->
      sig
        type a = V0.a list
        module T :
          sig
            type a = a
            val type_rep : unit -> Typeable.TypeRep.t
            val has_type : Typeable.dynamic -> bool
            val cast : Typeable.dynamic -> a option
            val throwing_cast : Typeable.dynamic -> a
            val make_dynamic : a -> Typeable.dynamic
            val mk : a -> Typeable.dynamic
          end
        module E : sig type a = a val eq : a -> a -> bool end
        val pickle : a -> id Write.m
        val unpickle : id -> a Read.m
        val to_buffer : Buffer.t -> a -> unit
        val to_string : a -> string
        val to_channel : out_channel -> a -> unit
        val from_stream : char Stream.t -> a
        val from_string : string -> a
        val from_channel : in_channel -> a
      end
  module Pickle_ref :
    functor (S : Pickle->
      sig
        type a = S.a ref
        module T :
          sig
            type a = a
            val type_rep : unit -> Typeable.TypeRep.t
            val has_type : Typeable.dynamic -> bool
            val cast : Typeable.dynamic -> a option
            val throwing_cast : Typeable.dynamic -> a
            val make_dynamic : a -> Typeable.dynamic
            val mk : a -> Typeable.dynamic
          end
        module E : sig type a = a val eq : a -> a -> bool end
        val pickle : a -> id Write.m
        val unpickle : id -> a Read.m
        val to_buffer : Buffer.t -> a -> unit
        val to_string : a -> string
        val to_channel : out_channel -> a -> unit
        val from_stream : char Stream.t -> a
        val from_string : string -> a
        val from_channel : in_channel -> a
      end
  module Pickle_from_dump :
    functor
      (P : Dump.Dump) (E : sig type a = P.a val eq : a -> a -> bool end) (T : 
      sig
        type a = P.a
        val type_rep : unit -> Typeable.TypeRep.t
        val has_type : Typeable.dynamic -> bool
        val cast : Typeable.dynamic -> a option
        val throwing_cast : Typeable.dynamic -> a
        val make_dynamic : a -> Typeable.dynamic
        val mk : a -> Typeable.dynamic
      end->
      sig
        type a = P.a
        module T :
          sig
            type a = a
            val type_rep : unit -> Typeable.TypeRep.t
            val has_type : Typeable.dynamic -> bool
            val cast : Typeable.dynamic -> a option
            val throwing_cast : Typeable.dynamic -> a
            val make_dynamic : a -> Typeable.dynamic
            val mk : a -> Typeable.dynamic
          end
        module E : sig type a = a val eq : a -> a -> bool end
        val pickle : a -> id Write.m
        val unpickle : id -> a Read.m
        val to_buffer : Buffer.t -> a -> unit
        val to_string : a -> string
        val to_channel : out_channel -> a -> unit
        val from_stream : char Stream.t -> a
        val from_string : string -> a
        val from_channel : in_channel -> a
      end
end