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->
      functor
        (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->
        functor
          (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->
      functor
        (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->
      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 = 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->
      functor (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->
      functor
        (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->
        functor (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->
      functor (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->
      functor (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->
      functor (Data : Datatype.S->
        functor (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->
      functor (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->
      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 = 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->
      functor (Info : Info->
        sig
          type elt = Data.t
          val add : elt -> unit
          val iter : (elt -> unit) -> unit
          val is_empty : unit -> bool
        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