refactor: update to containers 2.8 to get rid of warnings

Author: c-cube

mc2.opam

@@ -15,8 +15,8 @@ depends: [
   "ocaml" {>= "4.03.0"}
   "zarith"
   "menhir"
-  "containers" { >= "2.8" }
-  "iter"
+  "containers" { >= "2.8" & < "3.0" }
+  "iter" { >= "1.0" }
   "smtlib-utils" { >= "0.1" & < "0.2" }
   "dune" { >= "1.11" }
   "odoc" {with-doc}

src/core/Het_map.ml

@@ -113,22 +113,22 @@ module Tbl = struct
 
   let iter f t = M.iter (fun _ pair -> f (pair_of_e_pair pair)) t
 
-  let to_seq t yield = iter yield t
+  let to_iter t yield = iter yield t
 
   let to_list t = M.fold (fun _ p l -> pair_of_e_pair p::l) t []
 
   let add_list t l = List.iter (add_pair_ t) l
 
-  let add_seq t seq = seq (add_pair_ t)
+  let add_iter t seq = seq (add_pair_ t)
 
   let of_list l =
     let t = create() in
     add_list t l;
     t
 
-  let of_seq seq =
+  let of_iter seq =
     let t = create() in
-    add_seq t seq;
+    add_iter t seq;
     t
 end
 
@@ -171,18 +171,18 @@ module Map = struct
 
   let iter f t = M.iter (fun _ p -> f (pair_of_e_pair p)) t
 
-  let to_seq t yield = iter yield t
+  let to_iter t yield = iter yield t
 
   let to_list t = M.fold (fun _ p l -> pair_of_e_pair p::l) t []
 
   let add_list t l = List.fold_right add_pair_ l t
 
-  let add_seq t seq =
+  let add_iter t seq =
     let t = ref t in
     seq (fun pair -> t := add_pair_ pair !t);
     !t
 
   let of_list l = add_list empty l
 
-  let of_seq seq = add_seq empty seq
+  let of_iter seq = add_iter empty seq
 end

src/core/Het_map.mli

@@ -42,11 +42,11 @@ module Tbl : sig
 
   val iter : (pair -> unit) -> t -> unit
 
-  val to_seq : t -> pair sequence
+  val to_iter : t -> pair sequence
 
-  val of_seq : pair sequence -> t
+  val of_iter : pair sequence -> t
 
-  val add_seq : t -> pair sequence -> unit
+  val add_iter : t -> pair sequence -> unit
 
   val add_list : t -> pair list -> unit
 
@@ -76,11 +76,11 @@ module Map : sig
 
   val iter : (pair -> unit) -> t -> unit
 
-  val to_seq : t -> pair sequence
+  val to_iter : t -> pair sequence
 
-  val of_seq : pair sequence -> t
+  val of_iter : pair sequence -> t
 
-  val add_seq : t -> pair sequence -> t
+  val add_iter : t -> pair sequence -> t
 
   val add_list : t -> pair list -> t
 

src/core/Internal.ml

@@ -178,7 +178,7 @@ let[@inline] decision_level env = Vec.size env.decision_levels
 let[@inline] base_level env = Vec.size env.user_levels
 
 let[@inline] services env = env.services
-let[@inline] plugins env = CCVector.to_seq env.plugins
+let[@inline] plugins env = CCVector.to_iter env.plugins
 let[@inline] get_service env (k:_ Service.Key.t) =
   Service.Registry.find env.services k
 
@@ -229,7 +229,7 @@ let[@inline] is_unsat t = match t.unsat_conflict with
 
 (* iterate on all active terms *)
 let[@inline] iter_terms (env:t) : term Iter.t =
-  CCVector.to_seq env.plugins
+  CCVector.to_iter env.plugins
   |> Iter.flat_map
     (fun (module P : Plugin.S) -> P.iter_terms)
   |> Iter.filter Term.has_var

src/core/Proof.ml

@@ -321,11 +321,11 @@ module Check : sig
   val check : t -> unit
 end = struct
   let[@inline] set_of_c (c:clause): Atom.Set.t =
-    Iter.of_array c.c_atoms |> Atom.Set.of_seq
+    Iter.of_array c.c_atoms |> Atom.Set.of_iter
 
   let pp_a_set out (a:Atom.Set.t) : unit =
     Fmt.fprintf out "(@[<v>%a@])"
-      (Util.pp_seq ~sep:" ∨ " Atom.debug) (Atom.Set.to_seq a)
+      (Util.pp_seq ~sep:" ∨ " Atom.debug) (Atom.Set.to_iter a)
 
   (* state for one hyper{resolution,paramodulation} step *)
   type state = {

src/core/Service.ml

@@ -48,7 +48,7 @@ module Registry = struct
     r.lst <- Any (key,v) :: r.lst
 
   let[@inline] find (r:t) k = M.Tbl.find r.tbl k.Key.key
-  let[@inline] to_seq (r:t) = Iter.of_list r.lst
+  let[@inline] to_iter (r:t) = Iter.of_list r.lst
   let[@inline] find_exn r k = match find r k with
     | Some v -> v
     | None -> Error.errorf "could not find service `%s`" (Key.name k)

src/core/Service.mli

@@ -37,6 +37,6 @@ module Registry : sig
   (** Find a service by its key
       @raise Util.Error if the key is not found *)
 
-  val to_seq : t -> any Iter.t
+  val to_iter : t -> any Iter.t
   (** all registered services *)
 end

src/core/Vec.ml

@@ -90,12 +90,12 @@ let[@inline] iteri f t =
     f i (Array.unsafe_get t.data i)
   done
 
-let[@inline] to_seq a k = iter k a
+let[@inline] to_iter a k = iter k a
 
-let exists p t = Iter.exists p @@ to_seq t
-let for_all p t = Iter.for_all p @@ to_seq t
-let fold f acc a = Iter.fold f acc @@ to_seq a
-let to_list a = Iter.to_list @@ to_seq a
+let exists p t = Iter.exists p @@ to_iter t
+let for_all p t = Iter.for_all p @@ to_iter t
+let fold f acc a = Iter.fold f acc @@ to_iter a
+let to_list a = Iter.to_list @@ to_iter a
 let to_array a = Array.sub a.data 0 a.sz
 
 let of_list l : _ t =

src/core/Vec.mli

@@ -16,7 +16,7 @@ val to_array : 'a t -> 'a array
 
 val of_list : 'a list -> 'a t
 
-val to_seq : 'a t -> 'a Iter.t
+val to_iter : 'a t -> 'a Iter.t
 
 val clear : 'a t -> unit
 (** Set size to 0, doesn't free elements *)

src/lra/Linexp.ml

@@ -41,7 +41,7 @@ let[@inline] hash_q (n:Q.t) : int =
 
 let[@inline] hash (e:t) : int =
   let hash_pair (t,n) = CCHash.combine3 11 (Term.hash t) (hash_q n) in
-  CCHash.combine3 42 (hash_q e.const) (CCHash.seq hash_pair @@ TM.to_seq e.terms)
+  CCHash.combine3 42 (hash_q e.const) (CCHash.seq hash_pair @@ TM.to_iter e.terms)
 
 let[@inline] const n : t = {const=n; terms=TM.empty }
 let[@inline] is_const n : bool = TM.is_empty n.terms
@@ -113,7 +113,7 @@ let pp_no_paren out (e:t) : unit =
       else Fmt.fprintf out "%a·%a" Q.pp_print n Term.pp t
     in
     Fmt.fprintf out "%a%a"
-      (Util.pp_seq ~sep: " + " pp_pair) (TM.to_seq e.terms) pp_const e
+      (Util.pp_seq ~sep: " + " pp_pair) (TM.to_iter e.terms) pp_const e
   )
 
 let[@inline] pp out e = Fmt.fprintf out "(@[%a@])" pp_no_paren e