1 files changed, 8 insertions, 8 deletions

diff --git a/stdlib/listLabels.mli b/stdlib/listLabels.mli
index e11f29c001..3c2f9d761e 100644
--- a/stdlib/listLabels.mli
+++ b/stdlib/listLabels.mli
@@ -117,10 +117,10 @@ val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
         (* Same as [for_all] and [exists], but for a two-argument predicate.
            Raise [Invalid_argument] if the two lists have
            different lengths. *)
-val mem : 'a -> 'a list -> bool
+val mem : 'a -> set:'a list -> bool
         (* [mem a l] is true if and only if [a] is equal
            to an element of [l]. *)
-val memq : 'a -> 'a list -> bool
+val memq : 'a -> set:'a list -> bool
         (* Same as [mem], but uses physical equality instead of structural
            equality to compare list elements. *)
 
@@ -148,30 +148,30 @@ val partition : f:('a -> bool) -> 'a list -> 'a list * 'a list
 
 (** Association lists *)
 
-val assoc : 'a -> ('a * 'b) list -> 'b
+val assoc : 'a -> map:('a * 'b) list -> 'b
         (* [assoc a l] returns the value associated with key [a] in the list of
            pairs [l]. That is,
              [assoc a [ ...; (a,b); ...] = b]
            if [(a,b)] is the leftmost binding of [a] in list [l].
            Raise [Not_found] if there is no value associated with [a] in the
            list [l]. *)
-val assq : 'a -> ('a * 'b) list -> 'b
+val assq : 'a -> map:('a * 'b) list -> 'b
         (* Same as [assoc], but uses physical equality instead of structural
            equality to compare keys. *)
 
-val mem_assoc : 'a -> ('a * 'b) list -> bool
+val mem_assoc : 'a -> map:('a * 'b) list -> bool
         (* Same as [assoc], but simply return true if a binding exists,
            and false if no bindings exist for the given key. *)
-val mem_assq : 'a -> ('a * 'b) list -> bool
+val mem_assq : 'a -> map:('a * 'b) list -> bool
         (* Same as [mem_assoc], but uses physical equality instead of
            structural equality to compare keys. *)
 
-val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
+val remove_assoc : 'a -> map:('a * 'b) list -> ('a * 'b) list
         (* [remove_assoc a l] returns the list of
            pairs [l] without the first pair with key [a], if any.
            Not tail-recursive. *)
 
-val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
+val remove_assq : 'a -> map:('a * 'b) list -> ('a * 'b) list
         (* Same as [remove_assq], but uses physical equality instead
            of structural equality to compare keys.  Not tail-recursive. *)