Implement find_first, find_last for maps

Finds the first/last binding where the key satisfies a monotonic
predicate, returning an option.

Followup to ocaml#885.

stdlib/map.ml

@@ -52,7 +52,9 @@ module type S =
     val find: key -> 'a t -> 'a
     val find_opt: key -> 'a t -> 'a option
     val find_first: (key -> bool) -> 'a t -> key * 'a
+    val find_first_opt: (key -> bool) -> 'a t -> (key * 'a) option
     val find_last: (key -> bool) -> 'a t -> key * 'a
+    val find_last_opt: (key -> bool) -> 'a t -> (key * 'a) option
     val map: ('a -> 'b) -> 'a t -> 'b t
     val mapi: (key -> 'a -> 'b) -> 'a t -> 'b t
   end
@@ -149,6 +151,24 @@ module Make(Ord: OrderedType) = struct
           else
             find_first f r
 
+    let rec find_first_opt_aux v0 d0 f = function
+        Empty ->
+          Some (v0, d0)
+      | Node(l, v, d, r, _) ->
+          if f v then
+            find_first_opt_aux v d f l
+          else
+            find_first_opt_aux v0 d0 f r
+
+    let rec find_first_opt f = function
+        Empty ->
+          None
+      | Node(l, v, d, r, _) ->
+          if f v then
+            find_first_opt_aux v d f l
+          else
+            find_first_opt f r
+
     let rec find_last_aux v0 d0 f = function
         Empty ->
           (v0, d0)
@@ -167,6 +187,24 @@ module Make(Ord: OrderedType) = struct
           else
             find_last f l
 
+    let rec find_last_opt_aux v0 d0 f = function
+        Empty ->
+          Some (v0, d0)
+      | Node(l, v, d, r, _) ->
+          if f v then
+            find_last_opt_aux v d f r
+          else
+            find_last_opt_aux v0 d0 f l
+
+    let rec find_last_opt f = function
+        Empty ->
+          None
+      | Node(l, v, d, r, _) ->
+          if f v then
+            find_last_opt_aux v d f r
+          else
+            find_last_opt f l
+
     let rec find_opt x = function
         Empty ->
           None

stdlib/map.mli

@@ -243,11 +243,21 @@ module type S =
        returns the binding of [m] with the lowest key [k] such that [f k],
        or raises [Not_found] if no such key exists. *)
 
+    val find_first_opt: (key -> bool) -> 'a t -> (key * 'a) option
+    (** [find_first_opt f m], where f is a monotonically increasing function,
+       returns an option containing the binding of [m] with the lowest key [k]
+       such that [f k], or the [None] option if no such key exists. *)
+
     val find_last: (key -> bool) -> 'a t -> key * 'a
     (** [find_last f m], where f is a monotonically decreasing function,
        returns the binding of [m] with the highest key [k] such that [f k],
        or raises [Not_found] if no such key exists. *)
 
+    val find_last_opt: (key -> bool) -> 'a t -> (key * 'a) option
+    (** [find_last_opt f m], where f is a monotonically decreasing function,
+       returns an option containing the binding of [m] with the highest key [k]
+       such that [f k], or the [None] option if no such key exists. *)
+
     val map: ('a -> 'b) -> 'a t -> 'b t
     (** [map f m] returns a map with same domain as [m], where the
        associated value [a] of all bindings of [m] has been

stdlib/moreLabels.mli

@@ -141,7 +141,9 @@ module Map : sig
       val find : key -> 'a t -> 'a
       val find_opt: key -> 'a t -> 'a option
       val find_first : f:(key -> bool) -> 'a t -> key * 'a
+      val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option
       val find_last : f:(key -> bool) -> 'a t -> key * 'a
+      val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option
       val map : f:('a -> 'b) -> 'a t -> 'b t
       val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t
   end

testsuite/tests/lib-set/testmap.ml

@@ -115,6 +115,18 @@ let test x v s1 s2 =
         None -> (k, v) = M.min_binding r
       | Some v1 -> (k, v) = (x, v1));
 
+  checkbool "find_first_opt"
+    (let (l, p, r) = M.split x s1 in
+    if p = None && M.is_empty r then
+      match M.find_first_opt (fun k -> k >= x) s1 with
+        None -> true
+      | _ -> false
+    else
+      let Some (k, v) = M.find_first_opt (fun k -> k >= x) s1 in
+      match p with
+        None -> (k, v) = M.min_binding r
+      | Some v1 -> (k, v) = (x, v1));
+
   checkbool "find_last"
     (let (l, p, r) = M.split x s1 in
     if p = None && M.is_empty l then
@@ -129,6 +141,18 @@ let test x v s1 s2 =
         None -> (k, v) = M.max_binding l
       | Some v1 -> (k, v) = (x, v1));
 
+  checkbool "find_last_opt"
+    (let (l, p, r) = M.split x s1 in
+    if p = None && M.is_empty l then
+      match M.find_last_opt (fun k -> k <= x) s1 with
+        None -> true
+      | _ -> false
+    else
+      let Some (k, v) = M.find_last_opt (fun k -> k <= x) s1 in
+      match p with
+        None -> (k, v) = M.max_binding l
+      | Some v1 -> (k, v) = (x, v1));
+
   check "split"
     (let (l, p, r) = M.split x s1 in
      fun i ->

testsuite/tests/typing-implicit_unpack/implicit_unpack.ml.reference

@@ -107,7 +107,9 @@ module type MapT =
     val find : key -> 'a t -> 'a
     val find_opt : key -> 'a t -> 'a option
     val find_first : (key -> bool) -> 'a t -> key * 'a
+    val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
     val find_last : (key -> bool) -> 'a t -> key * 'a
+    val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
     val map : ('a -> 'b) -> 'a t -> 'b t
     val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
     type data
@@ -151,7 +153,9 @@ module SSMap :
     val find : key -> 'a t -> 'a
     val find_opt : key -> 'a t -> 'a option
     val find_first : (key -> bool) -> 'a t -> key * 'a
+    val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
     val find_last : (key -> bool) -> 'a t -> key * 'a
+    val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
     val map : ('a -> 'b) -> 'a t -> 'b t
     val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
     type data = string

testsuite/tests/typing-short-paths/short-paths.ml.reference

@@ -47,7 +47,9 @@
             val find : key -> 'a t -> 'a
             val find_opt : key -> 'a t -> 'a option
             val find_first : (key -> bool) -> 'a t -> key * 'a
+            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
             val find_last : (key -> bool) -> 'a t -> key * 'a
+            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
             val map : ('a -> 'b) -> 'a t -> 'b t
             val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
           end