sig
  module type Info =
    sig val name : string val dependencies : State.t list end
  module type Info_with_size =
    sig val name : string val dependencies : State.t list val size : int end
  module type S =
    sig
      val self : State.t
      val name : string
      val mark_as_computed : ?project:Project.t -> unit -> unit
      val is_computed : ?project:Project.t -> unit -> bool
      module Datatype : Datatype.S
      val add_hook_on_update : (Datatype.t -> unit) -> unit
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
    end
  module Register :
    functor
      (Datatype : Datatype.S) (Local_state : sig
                                               type t = Datatype.t
                                               val create : unit -> t
                                               val clear : t -> unit
                                               val get : unit -> t
                                               val set : t -> unit
                                               val clear_some_projects :
                                                 (Project_skeleton.t -> bool) ->
                                                 t -> bool
                                             end) (Info : sig
                                                            val name : string
                                                            val dependencies :
                                                              State.t list
                                                            val unique_name :
                                                              string
                                                          end->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype :
          sig
            type t = Datatype.t
            val ty : t Type.t
            val name : string
            val descr : t Descr.t
            val packed_descr : Structural_descr.pack
            val reprs : t list
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val hash : t -> int
            val pretty_code : Format.formatter -> t -> unit
            val internal_pretty_code :
              Type.precedence -> Format.formatter -> t -> unit
            val pretty : Format.formatter -> t -> unit
            val varname : t -> string
            val mem_project : (Project_skeleton.t -> bool) -> t -> bool
            val copy : t -> t
          end
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      end
  module type Ref =
    sig
      val self : State.t
      val name : string
      val mark_as_computed : ?project:Project.t -> unit -> unit
      val is_computed : ?project:Project.t -> unit -> bool
      module Datatype : Datatype.S
      val add_hook_on_update : (Datatype.t -> unit) -> unit
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      type data
      val set : State_builder.Ref.data -> unit
      val get : unit -> State_builder.Ref.data
      val clear : unit -> unit
    end
  module Ref :
    functor
      (Data : Datatype.S) (Info : sig
                                    val name : string
                                    val dependencies : State.t list
                                    val default : unit -> Data.t
                                  end->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = Data.t
        val set : data -> unit
        val get : unit -> data
        val clear : unit -> unit
      end
  module type Option_ref =
    sig
      val self : State.t
      val name : string
      val mark_as_computed : ?project:Project.t -> unit -> unit
      val is_computed : ?project:Project.t -> unit -> bool
      module Datatype : Datatype.S
      val add_hook_on_update : (Datatype.t -> unit) -> unit
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      type data
      val set : data -> unit
      val get : unit -> data
      val clear : unit -> unit
      val memo : ?change:(data -> data) -> (unit -> data) -> data
      val map : (data -> data) -> data option
      val may : (data -> unit) -> unit
      val get_option : unit -> data option
    end
  module Option_ref :
    functor (Data : Datatype.S) (Info : Info->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = Data.t
        val set : data -> unit
        val get : unit -> data
        val clear : unit -> unit
        val memo : ?change:(data -> data) -> (unit -> data) -> data
        val map : (data -> data) -> data option
        val may : (data -> unit) -> unit
        val get_option : unit -> data option
      end
  module type List_ref =
    sig
      type data_in_list
      val self : State.t
      val name : string
      val mark_as_computed : ?project:Project.t -> unit -> unit
      val is_computed : ?project:Project.t -> unit -> bool
      module Datatype : Datatype.S
      val add_hook_on_update : (Datatype.t -> unit) -> unit
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      type data
      val set : data -> unit
      val get : unit -> data
      val clear : unit -> unit
      val add : State_builder.List_ref.data_in_list -> unit
      val iter : (State_builder.List_ref.data_in_list -> unit) -> unit
      val fold_left :
        ('-> State_builder.List_ref.data_in_list -> 'a) -> '-> 'a
    end
  module List_ref :
    functor (Data : Datatype.S) (Info : Info->
      sig
        type data_in_list = Data.t
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = Data.t list
        val set : data -> unit
        val get : unit -> data
        val clear : unit -> unit
        val add : data_in_list -> unit
        val iter : (data_in_list -> unit) -> unit
        val fold_left : ('-> data_in_list -> 'a) -> '-> 'a
      end
  module Int_ref :
    functor
      (Info : sig
                val name : string
                val dependencies : State.t list
                val default : unit -> int
              end->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = int
        val set : data -> unit
        val get : unit -> data
        val clear : unit -> unit
      end
  module Zero_ref :
    functor (Info : Info->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = int
        val set : data -> unit
        val get : unit -> data
        val clear : unit -> unit
      end
  module Bool_ref :
    functor
      (Info : sig
                val name : string
                val dependencies : State.t list
                val default : unit -> bool
              end->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = bool
        val set : data -> unit
        val get : unit -> data
        val clear : unit -> unit
      end
  module False_ref :
    functor (Info : Info->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = bool
        val set : data -> unit
        val get : unit -> data
        val clear : unit -> unit
      end
  module True_ref :
    functor (Info : Info->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = bool
        val set : data -> unit
        val get : unit -> data
        val clear : unit -> unit
      end
  module Float_ref :
    functor
      (Info : sig
                val name : string
                val dependencies : State.t list
                val default : unit -> float
              end->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = float
        val set : data -> unit
        val get : unit -> data
        val clear : unit -> unit
      end
  module type Weak_hashtbl =
    sig
      val self : State.t
      val name : string
      val mark_as_computed : ?project:Project.t -> unit -> unit
      val is_computed : ?project:Project.t -> unit -> bool
      module Datatype : Datatype.S
      val add_hook_on_update : (Datatype.t -> unit) -> unit
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      type data
      val merge :
        State_builder.Weak_hashtbl.data -> State_builder.Weak_hashtbl.data
      val add : State_builder.Weak_hashtbl.data -> unit
      val clear : unit -> unit
      val count : unit -> int
      val iter : (State_builder.Weak_hashtbl.data -> unit) -> unit
      val fold : (State_builder.Weak_hashtbl.data -> '-> 'a) -> '-> 'a
      val find :
        State_builder.Weak_hashtbl.data -> State_builder.Weak_hashtbl.data
      val find_all :
        State_builder.Weak_hashtbl.data ->
        State_builder.Weak_hashtbl.data list
      val mem : State_builder.Weak_hashtbl.data -> bool
      val remove : State_builder.Weak_hashtbl.data -> unit
    end
  module Weak_hashtbl :
    functor
      (W : Weak.S) (Data : sig
                             type t = W.data
                             val ty : t Type.t
                             val name : string
                             val descr : t Descr.t
                             val packed_descr : Structural_descr.pack
                             val reprs : t list
                             val equal : t -> t -> bool
                             val compare : t -> t -> int
                             val hash : t -> int
                             val pretty_code : Format.formatter -> t -> unit
                             val internal_pretty_code :
                               Type.precedence ->
                               Format.formatter -> t -> unit
                             val pretty : Format.formatter -> t -> unit
                             val varname : t -> string
                             val mem_project :
                               (Project_skeleton.t -> bool) -> t -> bool
                             val copy : t -> t
                           end) (Info : Info_with_size->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = W.data
        val merge : data -> data
        val add : data -> unit
        val clear : unit -> unit
        val count : unit -> int
        val iter : (data -> unit) -> unit
        val fold : (data -> '-> 'a) -> '-> 'a
        val find : data -> data
        val find_all : data -> data list
        val mem : data -> bool
        val remove : data -> unit
      end
  module Caml_weak_hashtbl :
    functor (Data : Datatype.S) (Info : Info_with_size->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = Data.t
        val merge : data -> data
        val add : data -> unit
        val clear : unit -> unit
        val count : unit -> int
        val iter : (data -> unit) -> unit
        val fold : (data -> '-> 'a) -> '-> 'a
        val find : data -> data
        val find_all : data -> data list
        val mem : data -> bool
        val remove : data -> unit
      end
  module type Hashconsing_tbl =
    functor
      (Data : sig
                type t
                val ty : t Type.t
                val name : string
                val descr : t Descr.t
                val packed_descr : Structural_descr.pack
                val reprs : t list
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val hash : t -> int
                val pretty_code : Format.formatter -> t -> unit
                val internal_pretty_code :
                  Type.precedence -> Format.formatter -> t -> unit
                val pretty : Format.formatter -> t -> unit
                val varname : t -> string
                val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                val copy : t -> t
                val equal_internal : t -> t -> bool
                val hash_internal : t -> int
                val initial_values : t list
              end) (Info : Info_with_size->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = Data.t
        val merge : data -> data
        val add : data -> unit
        val clear : unit -> unit
        val count : unit -> int
        val iter : (data -> unit) -> unit
        val fold : (data -> '-> 'a) -> '-> 'a
        val find : data -> data
        val find_all : data -> data list
        val mem : data -> bool
        val remove : data -> unit
      end
  module Hashconsing_tbl_weak : Hashconsing_tbl
  module Hashconsing_tbl_not_weak : Hashconsing_tbl
  module Hashconsing_tbl : Hashconsing_tbl
  module type Hashtbl =
    sig
      val self : State.t
      val name : string
      val mark_as_computed : ?project:Project.t -> unit -> unit
      val is_computed : ?project:Project.t -> unit -> bool
      module Datatype : Datatype.S
      val add_hook_on_update : (Datatype.t -> unit) -> unit
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      type key
      type data
      val replace :
        State_builder.Hashtbl.key -> State_builder.Hashtbl.data -> unit
      val add :
        State_builder.Hashtbl.key -> State_builder.Hashtbl.data -> unit
      val clear : unit -> unit
      val length : unit -> int
      val iter :
        (State_builder.Hashtbl.key -> State_builder.Hashtbl.data -> unit) ->
        unit
      val iter_sorted :
        ?cmp:(State_builder.Hashtbl.key -> State_builder.Hashtbl.key -> int) ->
        (State_builder.Hashtbl.key -> State_builder.Hashtbl.data -> unit) ->
        unit
      val fold :
        (State_builder.Hashtbl.key -> State_builder.Hashtbl.data -> '-> 'a) ->
        '-> 'a
      val fold_sorted :
        ?cmp:(State_builder.Hashtbl.key -> State_builder.Hashtbl.key -> int) ->
        (State_builder.Hashtbl.key -> State_builder.Hashtbl.data -> '-> 'a) ->
        '-> 'a
      val memo :
        ?change:(State_builder.Hashtbl.data -> State_builder.Hashtbl.data) ->
        (State_builder.Hashtbl.key -> State_builder.Hashtbl.data) ->
        State_builder.Hashtbl.key -> State_builder.Hashtbl.data
      val find : State_builder.Hashtbl.key -> State_builder.Hashtbl.data
      val find_all :
        State_builder.Hashtbl.key -> State_builder.Hashtbl.data list
      val mem : State_builder.Hashtbl.key -> bool
      val remove : State_builder.Hashtbl.key -> unit
    end
  module Hashtbl :
    functor
      (H : Datatype.Hashtbl) (Data : Datatype.S) (Info : Info_with_size->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype :
          sig
            type t = Data.t H.t
            val ty : t Type.t
            val name : string
            val descr : t Descr.t
            val packed_descr : Structural_descr.pack
            val reprs : t list
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val hash : t -> int
            val pretty_code : Format.formatter -> t -> unit
            val internal_pretty_code :
              Type.precedence -> Format.formatter -> t -> unit
            val pretty : Format.formatter -> t -> unit
            val varname : t -> string
            val mem_project : (Project_skeleton.t -> bool) -> t -> bool
            val copy : t -> t
          end
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type key = H.key
        type data = Data.t
        val replace : key -> data -> unit
        val add : key -> data -> unit
        val clear : unit -> unit
        val length : unit -> int
        val iter : (key -> data -> unit) -> unit
        val iter_sorted :
          ?cmp:(key -> key -> int) -> (key -> data -> unit) -> unit
        val fold : (key -> data -> '-> 'a) -> '-> 'a
        val fold_sorted :
          ?cmp:(key -> key -> int) -> (key -> data -> '-> 'a) -> '-> 'a
        val memo : ?change:(data -> data) -> (key -> data) -> key -> data
        val find : key -> data
        val find_all : key -> data list
        val mem : key -> bool
        val remove : key -> unit
      end
  module Int_hashtbl :
    functor (Data : Datatype.S) (Info : Info_with_size->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type key = int
        type data = Data.t
        val replace : key -> data -> unit
        val add : key -> data -> unit
        val clear : unit -> unit
        val length : unit -> int
        val iter : (key -> data -> unit) -> unit
        val iter_sorted :
          ?cmp:(key -> key -> int) -> (key -> data -> unit) -> unit
        val fold : (key -> data -> '-> 'a) -> '-> 'a
        val fold_sorted :
          ?cmp:(key -> key -> int) -> (key -> data -> '-> 'a) -> '-> 'a
        val memo : ?change:(data -> data) -> (key -> data) -> key -> data
        val find : key -> data
        val find_all : key -> data list
        val mem : key -> bool
        val remove : key -> unit
      end
  module type Set_ref =
    sig
      val self : State.t
      val name : string
      val mark_as_computed : ?project:Project.t -> unit -> unit
      val is_computed : ?project:Project.t -> unit -> bool
      module Datatype : Datatype.S
      val add_hook_on_update : (Datatype.t -> unit) -> unit
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      type data
      val set : data -> unit
      val get : unit -> data
      val clear : unit -> unit
      type elt
      val add : State_builder.Set_ref.elt -> unit
      val remove : State_builder.Set_ref.elt -> unit
      val is_empty : unit -> bool
      val mem : State_builder.Set_ref.elt -> bool
      val fold : (State_builder.Set_ref.elt -> '-> 'a) -> '-> 'a
      val iter : (State_builder.Set_ref.elt -> unit) -> unit
    end
  module Set_ref :
    functor (S : Datatype.Set) (Info : Info->
      sig
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = S.t
        val set : data -> unit
        val get : unit -> data
        val clear : unit -> unit
        type elt = S.elt
        val add : elt -> unit
        val remove : elt -> unit
        val is_empty : unit -> bool
        val mem : elt -> bool
        val fold : (elt -> '-> 'a) -> '-> 'a
        val iter : (elt -> unit) -> unit
      end
  module type Queue =
    sig
      type elt
      val self : State.t
      val add : State_builder.Queue.elt -> unit
      val iter : (State_builder.Queue.elt -> unit) -> unit
      val is_empty : unit -> bool
    end
  module Queue :
    functor (Data : Datatype.S) (Info : Info->
      sig
        type elt = Data.t
        val self : State.t
        val add : elt -> unit
        val iter : (elt -> unit) -> unit
        val is_empty : unit -> bool
      end
  module type Array =
    sig
      type elt
      val length : unit -> int
      val set_length : int -> unit
      val get : int -> State_builder.Array.elt
      val set : int -> State_builder.Array.elt -> unit
      val iter : (State_builder.Array.elt -> unit) -> unit
      val iteri : (int -> State_builder.Array.elt -> unit) -> unit
      val fold_left : ('-> State_builder.Array.elt -> 'a) -> '-> 'a
      val fold_right : (State_builder.Array.elt -> '-> 'a) -> '-> 'a
    end
  module Array :
    functor
      (Data : Datatype.S) (Info : sig
                                    val name : string
                                    val dependencies : State.t list
                                    val default : Data.t
                                  end->
      sig
        type elt = Data.t
        val length : unit -> int
        val set_length : int -> unit
        val get : int -> elt
        val set : int -> elt -> unit
        val iter : (elt -> unit) -> unit
        val iteri : (int -> elt -> unit) -> unit
        val fold_left : ('-> elt -> 'a) -> '-> 'a
        val fold_right : (elt -> '-> 'a) -> '-> 'a
      end
  module Proxy :
    sig
      type t
      type kind = Backward | Forward | Both
      val create :
        string ->
        State_builder.Proxy.kind -> State.t list -> State_builder.Proxy.t
      val extend : State.t list -> State_builder.Proxy.t -> unit
      val get : State_builder.Proxy.t -> State.t
    end
  module type Counter =
    sig val next : unit -> int val get : unit -> int val self : State.t end
  module SharedCounter :
    functor (Info : sig val name : string end-> Counter
  module Counter : functor (Info : sig val name : string end-> Counter
  module type Hashcons =
    sig
      type elt
      type t
      val ty : t Type.t
      val name : string
      val descr : t Descr.t
      val packed_descr : Structural_descr.pack
      val reprs : t list
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val hash : t -> int
      val pretty_code : Format.formatter -> t -> unit
      val internal_pretty_code :
        Type.precedence -> Format.formatter -> t -> unit
      val pretty : Format.formatter -> t -> unit
      val varname : t -> string
      val mem_project : (Project_skeleton.t -> bool) -> t -> bool
      val copy : t -> t
      module Set :
        sig
          type elt = t
          type t
          val empty : t
          val is_empty : t -> bool
          val mem : elt -> t -> bool
          val add : elt -> t -> t
          val singleton : elt -> t
          val remove : elt -> t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val subset : t -> t -> bool
          val iter : (elt -> unit) -> t -> unit
          val fold : (elt -> '-> 'a) -> t -> '-> 'a
          val for_all : (elt -> bool) -> t -> bool
          val exists : (elt -> bool) -> t -> bool
          val filter : (elt -> bool) -> t -> t
          val partition : (elt -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> elt list
          val choose : t -> elt
          val split : elt -> t -> t * bool * t
          val find : elt -> t -> elt
          val of_list : elt list -> t
          val min_elt : t -> elt
          val max_elt : t -> elt
          val nearest_elt_le : elt -> t -> elt
          val nearest_elt_ge : elt -> t -> elt
          val ty : t Type.t
          val name : string
          val descr : t Descr.t
          val packed_descr : Structural_descr.pack
          val reprs : t list
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val hash : t -> int
          val pretty_code : Format.formatter -> t -> unit
          val internal_pretty_code :
            Type.precedence -> Format.formatter -> t -> unit
          val pretty : Format.formatter -> t -> unit
          val varname : t -> string
          val mem_project : (Project_skeleton.t -> bool) -> t -> bool
          val copy : t -> t
        end
      module Map :
        sig
          type key = t
          type +'a t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val add : key -> '-> 'a t -> 'a t
          val singleton : key -> '-> 'a t
          val remove : key -> 'a t -> 'a t
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val for_all : (key -> '-> bool) -> 'a t -> bool
          val exists : (key -> '-> bool) -> 'a t -> bool
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
          val cardinal : 'a t -> int
          val bindings : 'a t -> (key * 'a) list
          val min_binding : 'a t -> key * 'a
          val max_binding : 'a t -> key * 'a
          val choose : 'a t -> key * 'a
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          module Key :
            sig
              type t = key
              val ty : t Type.t
              val name : string
              val descr : t Descr.t
              val packed_descr : Structural_descr.pack
              val reprs : t list
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val hash : t -> int
              val pretty_code : Format.formatter -> t -> unit
              val internal_pretty_code :
                Type.precedence -> Format.formatter -> t -> unit
              val pretty : Format.formatter -> t -> unit
              val varname : t -> string
              val mem_project : (Project_skeleton.t -> bool) -> t -> bool
              val copy : t -> t
            end
          module Make :
            functor (Data : Datatype.S->
              sig
                type t = Data.t t
                val ty : t Type.t
                val name : string
                val descr : t Descr.t
                val packed_descr : Structural_descr.pack
                val reprs : t list
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val hash : t -> int
                val pretty_code : Format.formatter -> t -> unit
                val internal_pretty_code :
                  Type.precedence -> Format.formatter -> t -> unit
                val pretty : Format.formatter -> t -> unit
                val varname : t -> string
                val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                val copy : t -> t
              end
        end
      module Hashtbl :
        sig
          type key = t
          type 'a t
          val create : int -> 'a t
          val clear : 'a t -> unit
          val reset : 'a t -> unit
          val copy : 'a t -> 'a t
          val add : 'a t -> key -> '-> unit
          val remove : 'a t -> key -> unit
          val find : 'a t -> key -> 'a
          val find_all : 'a t -> key -> 'a list
          val replace : 'a t -> key -> '-> unit
          val mem : 'a t -> key -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val length : 'a t -> int
          val stats : 'a t -> Hashtbl.statistics
          val iter_sorted :
            ?cmp:(key -> key -> int) -> (key -> '-> unit) -> 'a t -> unit
          val fold_sorted :
            ?cmp:(key -> key -> int) ->
            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val iter_sorted_by_entry :
            cmp:(key * '-> key * '-> int) ->
            (key -> '-> unit) -> 'a t -> unit
          val fold_sorted_by_entry :
            cmp:(key * '-> key * '-> int) ->
            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val iter_sorted_by_value :
            cmp:('-> '-> int) -> (key -> '-> unit) -> 'a t -> unit
          val fold_sorted_by_value :
            cmp:('-> '-> int) ->
            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val structural_descr : Structural_descr.t -> Structural_descr.t
          val make_type : 'Type.t -> 'a t Type.t
          val memo : 'a t -> key -> (key -> 'a) -> 'a
          module Key :
            sig
              type t = key
              val ty : t Type.t
              val name : string
              val descr : t Descr.t
              val packed_descr : Structural_descr.pack
              val reprs : t list
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val hash : t -> int
              val pretty_code : Format.formatter -> t -> unit
              val internal_pretty_code :
                Type.precedence -> Format.formatter -> t -> unit
              val pretty : Format.formatter -> t -> unit
              val varname : t -> string
              val mem_project : (Project_skeleton.t -> bool) -> t -> bool
              val copy : t -> t
            end
          module Make :
            functor (Data : Datatype.S->
              sig
                type t = Data.t t
                val ty : t Type.t
                val name : string
                val descr : t Descr.t
                val packed_descr : Structural_descr.pack
                val reprs : t list
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val hash : t -> int
                val pretty_code : Format.formatter -> t -> unit
                val internal_pretty_code :
                  Type.precedence -> Format.formatter -> t -> unit
                val pretty : Format.formatter -> t -> unit
                val varname : t -> string
                val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                val copy : t -> t
              end
        end
      val hashcons : State_builder.Hashcons.elt -> t
      val get : t -> State_builder.Hashcons.elt
      val id : t -> int
      val self : State.t
    end
  module Hashcons :
    functor (Data : Datatype.S) (Info : Info->
      sig
        type elt = Data.t
        type t
        val ty : t Type.t
        val name : string
        val descr : t Descr.t
        val packed_descr : Structural_descr.pack
        val reprs : t list
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val hash : t -> int
        val pretty_code : Format.formatter -> t -> unit
        val internal_pretty_code :
          Type.precedence -> Format.formatter -> t -> unit
        val pretty : Format.formatter -> t -> unit
        val varname : t -> string
        val mem_project : (Project_skeleton.t -> bool) -> t -> bool
        val copy : t -> t
        module Set :
          sig
            type elt = t
            type t
            val empty : t
            val is_empty : t -> bool
            val mem : elt -> t -> bool
            val add : elt -> t -> t
            val singleton : elt -> t
            val remove : elt -> t -> t
            val union : t -> t -> t
            val inter : t -> t -> t
            val diff : t -> t -> t
            val subset : t -> t -> bool
            val iter : (elt -> unit) -> t -> unit
            val fold : (elt -> '-> 'a) -> t -> '-> 'a
            val for_all : (elt -> bool) -> t -> bool
            val exists : (elt -> bool) -> t -> bool
            val filter : (elt -> bool) -> t -> t
            val partition : (elt -> bool) -> t -> t * t
            val cardinal : t -> int
            val elements : t -> elt list
            val choose : t -> elt
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
            val of_list : elt list -> t
            val min_elt : t -> elt
            val max_elt : t -> elt
            val nearest_elt_le : elt -> t -> elt
            val nearest_elt_ge : elt -> t -> elt
            val ty : t Type.t
            val name : string
            val descr : t Descr.t
            val packed_descr : Structural_descr.pack
            val reprs : t list
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val hash : t -> int
            val pretty_code : Format.formatter -> t -> unit
            val internal_pretty_code :
              Type.precedence -> Format.formatter -> t -> unit
            val pretty : Format.formatter -> t -> unit
            val varname : t -> string
            val mem_project : (Project_skeleton.t -> bool) -> t -> bool
            val copy : t -> t
          end
        module Map :
          sig
            type key = t
            type +'a t
            val empty : 'a t
            val is_empty : 'a t -> bool
            val mem : key -> 'a t -> bool
            val add : key -> '-> 'a t -> 'a t
            val singleton : key -> '-> 'a t
            val remove : key -> 'a t -> 'a t
            val merge :
              (key -> 'a option -> 'b option -> 'c option) ->
              'a t -> 'b t -> 'c t
            val compare : ('-> '-> int) -> 'a t -> 'a t -> int
            val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
            val iter : (key -> '-> unit) -> 'a t -> unit
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val for_all : (key -> '-> bool) -> 'a t -> bool
            val exists : (key -> '-> bool) -> 'a t -> bool
            val filter : (key -> '-> bool) -> 'a t -> 'a t
            val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
            val cardinal : 'a t -> int
            val bindings : 'a t -> (key * 'a) list
            val min_binding : 'a t -> key * 'a
            val max_binding : 'a t -> key * 'a
            val choose : 'a t -> key * 'a
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
            module Key :
              sig
                type t = key
                val ty : t Type.t
                val name : string
                val descr : t Descr.t
                val packed_descr : Structural_descr.pack
                val reprs : t list
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val hash : t -> int
                val pretty_code : Format.formatter -> t -> unit
                val internal_pretty_code :
                  Type.precedence -> Format.formatter -> t -> unit
                val pretty : Format.formatter -> t -> unit
                val varname : t -> string
                val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                val copy : t -> t
              end
            module Make :
              functor (Data : Datatype.S->
                sig
                  type t = Data.t t
                  val ty : t Type.t
                  val name : string
                  val descr : t Descr.t
                  val packed_descr : Structural_descr.pack
                  val reprs : t list
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val hash : t -> int
                  val pretty_code : Format.formatter -> t -> unit
                  val internal_pretty_code :
                    Type.precedence -> Format.formatter -> t -> unit
                  val pretty : Format.formatter -> t -> unit
                  val varname : t -> string
                  val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                  val copy : t -> t
                end
          end
        module Hashtbl :
          sig
            type key = t
            type 'a t
            val create : int -> 'a t
            val clear : 'a t -> unit
            val reset : 'a t -> unit
            val copy : 'a t -> 'a t
            val add : 'a t -> key -> '-> unit
            val remove : 'a t -> key -> unit
            val find : 'a t -> key -> 'a
            val find_all : 'a t -> key -> 'a list
            val replace : 'a t -> key -> '-> unit
            val mem : 'a t -> key -> bool
            val iter : (key -> '-> unit) -> 'a t -> unit
            val filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val iter_sorted :
              ?cmp:(key -> key -> int) -> (key -> '-> unit) -> 'a t -> unit
            val fold_sorted :
              ?cmp:(key -> key -> int) ->
              (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val iter_sorted_by_entry :
              cmp:(key * '-> key * '-> int) ->
              (key -> '-> unit) -> 'a t -> unit
            val fold_sorted_by_entry :
              cmp:(key * '-> key * '-> int) ->
              (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val iter_sorted_by_value :
              cmp:('-> '-> int) -> (key -> '-> unit) -> 'a t -> unit
            val fold_sorted_by_value :
              cmp:('-> '-> int) ->
              (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val structural_descr : Structural_descr.t -> Structural_descr.t
            val make_type : 'Type.t -> 'a t Type.t
            val memo : 'a t -> key -> (key -> 'a) -> 'a
            module Key :
              sig
                type t = key
                val ty : t Type.t
                val name : string
                val descr : t Descr.t
                val packed_descr : Structural_descr.pack
                val reprs : t list
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val hash : t -> int
                val pretty_code : Format.formatter -> t -> unit
                val internal_pretty_code :
                  Type.precedence -> Format.formatter -> t -> unit
                val pretty : Format.formatter -> t -> unit
                val varname : t -> string
                val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                val copy : t -> t
              end
            module Make :
              functor (Data : Datatype.S->
                sig
                  type t = Data.t t
                  val ty : t Type.t
                  val name : string
                  val descr : t Descr.t
                  val packed_descr : Structural_descr.pack
                  val reprs : t list
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val hash : t -> int
                  val pretty_code : Format.formatter -> t -> unit
                  val internal_pretty_code :
                    Type.precedence -> Format.formatter -> t -> unit
                  val pretty : Format.formatter -> t -> unit
                  val varname : t -> string
                  val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                  val copy : t -> t
                end
          end
        val hashcons : elt -> t
        val get : t -> elt
        val id : t -> int
        val self : State.t
      end
  val apply_once :
    string -> State.t list -> (unit -> unit) -> (unit -> unit) * State.t
  module States :
    sig
      val iter :
        ?prj:Project.t -> (string -> 'Type.t -> '-> bool -> unit) -> unit
      val fold :
        ?prj:Project.t ->
        (string -> 'Type.t -> '-> bool -> 'acc -> 'acc) -> 'acc -> 'acc
      val find : ?prj:Project.t -> string -> 'Type.t -> 'a * bool
    end
end