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 sideeffects).
The implementation uses balanced binary trees, and therefore searching
and insertion take time logarithmic in the size of the map.
type ('a, 'b) t

The type of maps from type 'a to type 'b.
value empty: ('a > 'a > int) > ('a, 'b) t

The empty map.
The argument is a total ordering function over the set elements.
This is a twoargument function f such that
f e1 e2 is zero if the elements 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 eq__compare.
value add: 'a > 'b > ('a, 'b) t > ('a, 'b) t

add x y m returns a map containing the same bindings as
m, plus a binding of x to y. Previous bindings for x
in m are not removed, but simply hidden: they reappear
after performing a remove operation.
(This is the semantics of association lists.)
value find:'a > ('a, 'b) t > 'b

find x m returns the current binding of x in m,
or raises Not_found if no such binding exists.
value remove: 'a > ('a, 'b) t > ('a, 'b) t

remove x m returns a map containing the same bindings
as m except the current binding for x. The previous
binding for x is restored if it exists. m is returned
unchanged if x is not bound in m.
value iter: ('a > 'b > unit) > ('a, 'b) 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.