flambda-backend: Clean up algorithms (#611)

Author: lukemaurer

utils/strongly_connected_components.ml

@@ -107,8 +107,52 @@ end = struct
     }
 end
 
+module type Id = sig
+  type t
+
+  module Set : sig
+    type elt = t
+
+    type t
+
+    val empty : t
+
+    val add : elt -> t -> t
+
+    val elements : t -> elt list
+
+    val iter : (elt -> unit) -> t -> unit
+
+    val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+  end
+
+  module Map : sig
+    type key = t
+
+    type 'a t
+
+    val empty : _ t
+
+    val add : key -> 'a -> 'a t -> 'a t
+
+    val cardinal : _ t -> int
+
+    val bindings : 'a t -> (key * 'a) list
+
+    val find : key -> 'a t -> 'a
+
+    val iter : (key -> 'a -> unit) -> 'a t -> unit
+
+    val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+
+    val mem : key -> 'a t -> bool
+  end
+
+  val print : Format.formatter -> t -> unit
+end
+
 module type S = sig
-  module Id : Identifiable.S
+  module Id : Id
 
   type directed_graph = Id.Set.t Id.Map.t
 
@@ -123,7 +167,7 @@ module type S = sig
   val component_graph : directed_graph -> (component * int list) array
 end
 
-module Make (Id : Identifiable.S) = struct
+module Make (Id : Id) = struct
   type directed_graph = Id.Set.t Id.Map.t
 
   type component =
@@ -176,6 +220,11 @@ module Make (Id : Identifiable.S) = struct
     in
     { back; forth }, integer_graph
 
+  let rec int_list_mem x xs =
+    match xs with
+    | [] -> false
+    | x' :: xs -> if Int.equal x x' then true else int_list_mem x xs
+
   let component_graph graph =
     let numbering, integer_graph = number graph in
     let { Kosaraju. sorted_connected_components;
@@ -186,7 +235,7 @@ module Make (Id : Identifiable.S) = struct
         match nodes with
         | [] -> assert false
         | [node] ->
-          (if List.mem node integer_graph.(node)
+          (if int_list_mem node integer_graph.(node)
            then Has_loop [numbering.forth.(node)]
            else No_loop numbering.forth.(node)),
             component_edges.(component)

utils/strongly_connected_components.mli

@@ -21,8 +21,52 @@
 
 *)
 
+module type Id = sig
+  type t
+
+  module Set : sig
+    type elt = t
+
+    type t
+
+    val empty : t
+
+    val add : elt -> t -> t
+
+    val elements : t -> elt list
+
+    val iter : (elt -> unit) -> t -> unit
+
+    val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+  end
+
+  module Map : sig
+    type key = t
+
+    type 'a t
+
+    val empty : _ t
+
+    val add : key -> 'a -> 'a t -> 'a t
+
+    val cardinal : _ t -> int
+
+    val bindings : 'a t -> (key * 'a) list
+
+    val find : key -> 'a t -> 'a
+
+    val iter : (key -> 'a -> unit) -> 'a t -> unit
+
+    val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+
+    val mem : key -> 'a t -> bool
+  end
+
+  val print : Format.formatter -> t -> unit
+end
+
 module type S = sig
-  module Id : Identifiable.S
+  module Id : Id
 
   type directed_graph = Id.Set.t Id.Map.t
   (** If (a -> set) belongs to the map, it means that there are edges
@@ -40,4 +84,4 @@ module type S = sig
   val component_graph : directed_graph -> (component * int list) array
 end
 
-module Make (Id : Identifiable.S) : S with module Id := Id
+module Make (Id : Id) : S with module Id := Id