Commit da19866f authored by POTTIER Francois's avatar POTTIER Francois

Added the module [Maps and [Boolean], which are companions to [Fix].

parent 01055854
(* The Boolean lattice. *)
type property =
bool
let bottom =
false
let equal (b1 : bool) (b2 : bool) =
b1 = b2
let is_maximal b =
b
include Fix.PROPERTY with type property = bool
(* BEGIN PERSISTENT_MAPS *)
module type PERSISTENT_MAPS = sig
type key
type 'data t
val empty: 'data t
val add: key -> 'data -> 'data t -> 'data t
val find: key -> 'data t -> 'data
val iter: (key -> 'data -> unit) -> 'data t -> unit
end
(* END PERSISTENT_MAPS *)
(* BEGIN IMPERATIVE_MAPS *)
module type IMPERATIVE_MAPS = sig
type key
type 'data t
val create: unit -> 'data t
val clear: 'data t -> unit
val add: key -> 'data -> 'data t -> unit
val find: key -> 'data t -> 'data
val iter: (key -> 'data -> unit) -> 'data t -> unit
end
(* END IMPERATIVE_MAPS *)
(* BEGIN IMPERATIVE_MAP *)
module type IMPERATIVE_MAP = sig
type key
type data
val set: key -> data -> unit
val get: key -> data option
end
(* END IMPERATIVE_MAP *)
module PersistentMapsToImperativeMaps
(M : PERSISTENT_MAPS)
: IMPERATIVE_MAPS with type key = M.key
and type 'data t = 'data M.t ref
= struct
type key =
M.key
type 'data t =
'data M.t ref
let create () =
ref M.empty
let clear t =
t := M.empty
let add k d t =
t := M.add k d !t
let find k t =
M.find k !t
let iter f t =
M.iter f !t
end
module ImperativeMapsToImperativeMap
(M : IMPERATIVE_MAPS)
(D : sig type data end)
: IMPERATIVE_MAP with type key = M.key
and type data = D.data
= struct
type key =
M.key
type data =
D.data
let m =
M.create()
let set k d =
M.add k d m
let get k =
try
Some (M.find k m)
with Not_found ->
None
end
module ConsecutiveIntegerKeysToImperativeMaps
(K : sig val n: int end)
: IMPERATIVE_MAPS with type key = int
and type 'data t = 'data option array
= struct
open K
type key =
int
type 'data t =
'data option array
let create () =
Array.make n None
let clear m =
Array.fill m 0 n None
let add key data m =
m.(key) <- Some data
let find key m =
match m.(key) with
| None ->
raise Not_found
| Some data ->
data
let iter f m =
Array.iteri (fun key data ->
match data with
| None ->
()
| Some data ->
f key data
) m
end
module HashTableAsImperativeMaps
(H : Hashtbl.HashedType)
: IMPERATIVE_MAPS with type key = H.t
= struct
include Hashtbl.Make(H)
let create () =
create 1023
let add key data table =
add table key data
let find table key =
find key table
end
module TrivialHashedType
(T : sig type t end)
: Hashtbl.HashedType with type t = T.t
= struct
include T
let equal =
(=)
let hash =
Hashtbl.hash
end
(* This module defines three signatures for association maps, together
with a number of conversion functors. *)
(* Following the convention of the ocaml standard library, the [find]
functions raise [Not_found] when the key is not a member of the
domain of the map. By contrast, [get] returns an option. *)
(* BEGIN PERSISTENT_MAPS *)
module type PERSISTENT_MAPS = sig
type key
type 'data t
val empty: 'data t
val add: key -> 'data -> 'data t -> 'data t
val find: key -> 'data t -> 'data
val iter: (key -> 'data -> unit) -> 'data t -> unit
end
(* END PERSISTENT_MAPS *)
(* BEGIN IMPERATIVE_MAPS *)
module type IMPERATIVE_MAPS = sig
type key
type 'data t
val create: unit -> 'data t
val clear: 'data t -> unit
val add: key -> 'data -> 'data t -> unit
val find: key -> 'data t -> 'data
val iter: (key -> 'data -> unit) -> 'data t -> unit
end
(* END IMPERATIVE_MAPS *)
(* BEGIN IMPERATIVE_MAP *)
module type IMPERATIVE_MAP = sig
type key
type data
val set: key -> data -> unit
val get: key -> data option
end
(* END IMPERATIVE_MAP *)
(* An implementation of persistent maps can be made to satisfy the interface
of imperative maps. An imperative map is represented as a persistent map,
wrapped within a reference cell. *)
module PersistentMapsToImperativeMaps
(M : PERSISTENT_MAPS)
: IMPERATIVE_MAPS with type key = M.key
and type 'data t = 'data M.t ref
(* An implementation of imperative maps can be made to satisfy the interface
of a single imperative map. This map is obtained via a single call to [create]. *)
module ImperativeMapsToImperativeMap
(M : IMPERATIVE_MAPS)
(D : sig type data end)
: IMPERATIVE_MAP with type key = M.key
and type data = D.data
(* An implementation of imperative maps as arrays is possible if keys
are consecutive integers. *)
module ConsecutiveIntegerKeysToImperativeMaps
(K : sig val n: int end)
: IMPERATIVE_MAPS with type key = int
and type 'data t = 'data option array
(* An implementation of imperative maps as a hash table. *)
module HashTableAsImperativeMaps
(H : Hashtbl.HashedType)
: IMPERATIVE_MAPS with type key = H.t
(* A trivial implementation of equality and hashing. *)
module TrivialHashedType
(T : sig type t end)
: Hashtbl.HashedType with type t = T.t
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment