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 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 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 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 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
  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