unikernel/duniverse/dune_/otherlibs/ordering/ordering.mli

@@ -0,0 +1,51 @@
+(** Element ordering *)
+
+type t =
+  | Lt (** Lesser than *)
+  | Eq (** Equal *)
+  | Gt (** Greater than *)
+
+val of_int : int -> t
+val to_int : t -> int
+
+(** returns the string representation. one of: "<", "=", ">" *)
+val to_string : t -> string
+
+val is_eq : t -> bool
+val min : ('a -> 'a -> t) -> 'a -> 'a -> 'a
+val max : ('a -> 'a -> t) -> 'a -> 'a -> 'a
+
+(** [reverse cmp] takes a comparison function [cmp] and returns a new comparison
+    function whose comparisons are the opposite of that of [cmp]. *)
+val reverse : ('a -> 'a -> t) -> 'a -> 'a -> t
+
+module O : sig
+  (** A convenient operator for efficiently chaining multiple comparisons
+      together. For example, you can write
+
+      {v
+          let compare { x; y; z } t =
+            let open Ordering.O in
+            let= () = compare_x x t.x in
+            let= () = compare_y y t.y in
+            compare_z z t.z
+      v}
+
+      or, a bit less compactly but more symmetrically
+
+      {v
+          let compare { x; y; z } t =
+            let open Ordering.O in
+            let= () = compare_x x t.x in
+            let= () = compare_y y t.y in
+            let= () = compare_z z t.z in
+            Eq
+      v}
+
+      to chain three comparisons instead of the usual triply nested [match].
+
+      Note that the resulting code can be up to 2x slower than nested [match]ing
+      due to extra allocations that we are unable to eliminate (as of Nov 2021),
+      so you should use [let=] only where appropriate. *)
+  val ( let= ) : t -> (unit -> t) -> t
+end