1 files changed, 39 insertions, 1 deletions
diff --git a/stdlib/map.mli b/stdlib/map.mli
index 38e2e85e7..aaf21834b 100644
--- a/stdlib/map.mli
+++ b/stdlib/map.mli
@@ -1,20 +1,58 @@
-(* Maps over ordered types *)
+(* Module [Map]: association tables over ordered types *)
+
+(* This module implements applicative association tables, also known as
+   finite maps or dictionaries, given a total ordering function
+   over the keys.
+   All operations over maps are purely applicative (no side-effects).
+   The implementation uses balanced binary trees, and therefore searching
+   and insertion take time logarithmic in the size of the map. *)
 
 module type OrderedType =
   sig
     type t
     val compare: t -> t -> int
   end
+          (* The input signature of the functor [Map.Make].
+             [t] is the type of the map keys.
+             [compare] is a total ordering function over the keys.
+             This is a two-argument function [f] such that
+             [f e1 e2] is zero if the keys [e1] and [e2] are equal,
+             [f e1 e2] is strictly negative if [e1] is smaller than [e2],
+             and [f e1 e2] is strictly positive if [e1] is greater than [e2].
+             Examples: a suitable ordering function for type [int]
+             is [prefix -]. You can also use the generic structural comparison
+             function [compare]. *)
 
 module type S =
   sig
     type key
+          (* The type of the map keys. *)
     type 'a t
+          (* The type of maps from type [key] to type ['a]. *)
     val empty: 'a t
+          (* The empty map. *)
     val add: key -> 'a -> 'a t -> 'a t
+        (* [add x y m] returns a map containing the same bindings as
+           [m], plus a binding of [x] to [y]. If [x] was already bound
+           in [m], its previous binding disappears. *)
     val find: key -> 'a t -> 'a
+        (* [find x m] returns the current binding of [x] in [m],
+           or raises [Not_found] if no such binding exists. *)
     val iter: (key -> 'a -> 'b) -> 'a t -> unit
+        (* [iter f m] applies [f] to all bindings in map [m],
+	   discarding the results.
+           [f] receives the key as first argument, and the associated value
+           as second argument. The order in which the bindings are passed to
+           [f] is unspecified. Only current bindings are presented to [f]:
+           bindings hidden by more recent bindings are not passed to [f]. *)
     val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+        (* [fold f m a] computes [(f kN dN ... (f k1 d1 a)...)],
+           where [k1 ... kN] are the keys of all bindings in [m],
+           and [d1 ... dN] are the associated data.
+           The order in which the bindings are presented to [f] is
+           not specified. *)
   end
 
 module Make(Ord: OrderedType): (S with key = Ord.t)
+        (* Functor building an implementation of the map structure
+           given a totally ordered type. *)