sig
  module type IndexedType =
    sig
      type t
      val index : Index.IndexedType.t -> int
      val inverse : int -> Index.IndexedType.t
    end
  module type Map =
    sig
      type key
      type 'a t
      val size : 'a Index.Map.t -> int
      val create : 'a -> 'a Index.Map.t
      val is_empty : 'a Index.Map.t -> bool
      val mem : 'a Index.Map.t -> Index.Map.key -> bool
      val find : 'a Index.Map.t -> Index.Map.key -> 'a
      val add : 'a Index.Map.t -> Index.Map.key -> 'a -> unit
      val replace : 'a Index.Map.t -> Index.Map.key -> 'a -> unit
      val copy : 'a Index.Map.t -> 'a Index.Map.t
      val iter : (Index.Map.key -> 'a -> unit) -> 'a Index.Map.t -> unit
      val iter_const :
        ('a -> Index.Map.key -> 'b -> unit) -> 'a -> 'b Index.Map.t -> unit
      val fold :
        ('a -> Index.Map.key -> 'b -> 'a) -> 'a -> 'b Index.Map.t -> 'a
      val fold_const :
        ('a -> 'b -> Index.Map.key -> 'c -> 'b) ->
        'a -> 'b -> 'c Index.Map.t -> 'b
      val modify : ('a -> 'a) -> 'a Index.Map.t -> unit
      val modify_const : ('a -> 'b -> 'b) -> 'a -> 'b Index.Map.t -> unit
      val set_all : 'a Index.Map.t -> 'a -> unit
    end
  module Make_map :
    functor (I : IndexedType) ->
      sig
        type key = I.t
        type 'a t
        val size : 'a t -> int
        val create : 'a -> 'a t
        val is_empty : 'a t -> bool
        val mem : 'a t -> key -> bool
        val find : 'a t -> key -> 'a
        val add : 'a t -> key -> 'a -> unit
        val replace : 'a t -> key -> 'a -> unit
        val copy : 'a t -> 'a t
        val iter : (key -> 'a -> unit) -> 'a t -> unit
        val iter_const : ('a -> key -> 'b -> unit) -> 'a -> 'b t -> unit
        val fold : ('a -> key -> 'b -> 'a) -> 'a -> 'b t -> 'a
        val fold_const :
          ('a -> 'b -> key -> 'c -> 'b) -> 'a -> 'b -> 'c t -> 'b
        val modify : ('a -> 'a) -> 'a t -> unit
        val modify_const : ('a -> 'b -> 'b) -> 'a -> 'b t -> unit
        val set_all : 'a t -> 'a -> unit
      end
  module Nat_map :
    sig
      type key = int
      type 'a t
      val size : 'a t -> int
      val create : 'a -> 'a t
      val is_empty : 'a t -> bool
      val mem : 'a t -> key -> bool
      val find : 'a t -> key -> 'a
      val add : 'a t -> key -> 'a -> unit
      val replace : 'a t -> key -> 'a -> unit
      val copy : 'a t -> 'a t
      val iter : (key -> 'a -> unit) -> 'a t -> unit
      val iter_const : ('a -> key -> 'b -> unit) -> 'a -> 'b t -> unit
      val fold : ('a -> key -> 'b -> 'a) -> 'a -> 'b t -> 'a
      val fold_const :
        ('a -> 'b -> key -> 'c -> 'b) -> 'a -> 'b -> 'c t -> 'b
      val modify : ('a -> 'a) -> 'a t -> unit
      val modify_const : ('a -> 'b -> 'b) -> 'a -> 'b t -> unit
      val set_all : 'a t -> 'a -> unit
    end
  module type Map2 =
    sig
      type key0
      type key1
      type 'a t
      val create : int -> int -> 'a Index.Map2.t
      val mem : 'a Index.Map2.t -> Index.Map2.key0 -> Index.Map2.key1 -> bool
      val find : 'a Index.Map2.t -> Index.Map2.key0 -> Index.Map2.key1 -> 'a
      val set :
        'a Index.Map2.t -> Index.Map2.key0 -> Index.Map2.key1 -> 'a -> unit
      val remove :
        'a Index.Map2.t -> Index.Map2.key0 -> Index.Map2.key1 -> unit
    end
  module Nat_map2 :
    functor (J : Hashtbl.HashedType) ->
      sig
        type key0 = int
        type key1 = J.t
        type 'a t
        val create : int -> int -> 'a t
        val mem : 'a t -> key0 -> key1 -> bool
        val find : 'a t -> key0 -> key1 -> 'a
        val set : 'a t -> key0 -> key1 -> 'a -> unit
        val remove : 'a t -> key0 -> key1 -> unit
      end
  module Make_map2 :
    functor (I : IndexedType) ->
      functor (J : Hashtbl.HashedType) ->
        sig
          type key0 = I.t
          type key1 = J.t
          type 'a t
          val create : int -> int -> 'a t
          val mem : 'a t -> key0 -> key1 -> bool
          val find : 'a t -> key0 -> key1 -> 'a
          val set : 'a t -> key0 -> key1 -> 'a -> unit
          val remove : 'a t -> key0 -> key1 -> unit
        end
  module type Set =
    sig
      type elt
      type t
      val create : unit -> Index.Set.t
      val size : Index.Set.t -> int
      val is_empty : Index.Set.t -> bool
      val mem : Index.Set.t -> Index.Set.elt -> bool
      val add : Index.Set.t -> Index.Set.elt -> unit
      val remove : Index.Set.t -> Index.Set.elt -> unit
      val clear : Index.Set.t -> unit
      val iter : (Index.Set.elt -> unit) -> Index.Set.t -> unit
      val iter_const :
        ('a -> Index.Set.elt -> unit) -> 'a -> Index.Set.t -> unit
      val fold : ('a -> Index.Set.elt -> 'a) -> 'a -> Index.Set.t -> 'a
      val fold_const :
        ('a -> 'b -> Index.Set.elt -> 'b) -> 'a -> 'b -> Index.Set.t -> 'b
    end
  module Make_set :
    functor (I : IndexedType) ->
      sig
        type elt = I.t
        type t
        val create : unit -> t
        val size : t -> int
        val is_empty : t -> bool
        val mem : t -> elt -> bool
        val add : t -> elt -> unit
        val remove : t -> elt -> unit
        val clear : t -> unit
        val iter : (elt -> unit) -> t -> unit
        val iter_const : ('a -> elt -> unit) -> 'a -> t -> unit
        val fold : ('a -> elt -> 'a) -> 'a -> t -> 'a
        val fold_const : ('a -> 'b -> elt -> 'b) -> 'a -> 'b -> t -> 'b
      end
  module Nat_set :
    sig
      type elt = int
      type t
      val create : unit -> t
      val size : t -> int
      val is_empty : t -> bool
      val mem : t -> elt -> bool
      val add : t -> elt -> unit
      val remove : t -> elt -> unit
      val clear : t -> unit
      val iter : (elt -> unit) -> t -> unit
      val iter_const : ('a -> elt -> unit) -> 'a -> t -> unit
      val fold : ('a -> elt -> 'a) -> 'a -> t -> 'a
      val fold_const : ('a -> 'b -> elt -> 'b) -> 'a -> 'b -> t -> 'b
    end
  module Make_hashed_set :
    functor (H : Hashtbl.HashedType) ->
      sig
        type elt = H.t
        type t
        val create : unit -> t
        val size : t -> int
        val is_empty : t -> bool
        val mem : t -> elt -> bool
        val add : t -> elt -> unit
        val remove : t -> elt -> unit
        val clear : t -> unit
        val iter : (elt -> unit) -> t -> unit
        val iter_const : ('a -> elt -> unit) -> 'a -> t -> unit
        val fold : ('a -> elt -> 'a) -> 'a -> t -> 'a
        val fold_const : ('a -> 'b -> elt -> 'b) -> 'a -> 'b -> t -> 'b
      end
  module type PriorityQueue =
    sig
      type elt
      type t
      val create : Index.PriorityQueue.elt -> Index.PriorityQueue.t
      val length : Index.PriorityQueue.t -> int
      val is_empty : Index.PriorityQueue.t -> bool
      val mem : Index.PriorityQueue.t -> Index.PriorityQueue.elt -> bool
      val head : Index.PriorityQueue.t -> Index.PriorityQueue.elt
      val enqueue : Index.PriorityQueue.t -> Index.PriorityQueue.elt -> unit
      val dequeue : Index.PriorityQueue.t -> Index.PriorityQueue.elt
      val drop : Index.PriorityQueue.t -> unit
      val priority :
        Index.PriorityQueue.t -> Index.PriorityQueue.elt -> float
      val inc_priority :
        Index.PriorityQueue.t -> Index.PriorityQueue.elt -> float -> unit
      val scale : Index.PriorityQueue.t -> float -> unit
    end
  module Make_priority_queue :
    functor (I : IndexedType) ->
      sig
        type elt = I.t
        type t
        val create : elt -> t
        val length : t -> int
        val is_empty : t -> bool
        val mem : t -> elt -> bool
        val head : t -> elt
        val enqueue : t -> elt -> unit
        val dequeue : t -> elt
        val drop : t -> unit
        val priority : t -> elt -> float
        val inc_priority : t -> elt -> float -> unit
        val scale : t -> float -> unit
      end
  module Nat_priority_queue :
    sig
      type elt = int
      type t
      val create : elt -> t
      val length : t -> int
      val is_empty : t -> bool
      val mem : t -> elt -> bool
      val head : t -> elt
      val enqueue : t -> elt -> unit
      val dequeue : t -> elt
      val drop : t -> unit
      val priority : t -> elt -> float
      val inc_priority : t -> elt -> float -> unit
      val scale : t -> float -> unit
    end
end

---

Hosted by the ^* web site.
^*Other names and brands may be claimed as the property of others.