diff --git a/src/data/CCBV.ml b/src/data/CCBV.ml
index 7c3aa884..59134951 100644
--- a/src/data/CCBV.ml
+++ b/src/data/CCBV.ml
@@ -258,20 +258,20 @@ let iter bv f =
 *)
 
 (*$inject
-  let seq_zip s k = s (fun x y -> k(x,y))
+  let iter_zip s k = s (fun x y -> k(x,y))
 *)
 
 (*$= & ~printer:Q.Print.(list (pair int bool))
-  [] (iter (create ~size:0 false) |> seq_zip |> Iter.to_list)
+  [] (iter (create ~size:0 false) |> iter_zip |> Iter.to_list)
   [0, false; 1, true; 2, false] \
-    (iter (let bv = create ~size:3 false in set bv 1; bv) |> seq_zip |> Iter.to_list)
+    (iter (let bv = create ~size:3 false in set bv 1; bv) |> iter_zip |> Iter.to_list)
 *)
 
 (*$Q
   Q.(small_int) (fun n -> \
     assert (n >= 0); \
     let bv = create ~size:n true in \
-    let l = iter bv |> seq_zip |> Iter.to_list in \
+    let l = iter bv |> iter_zip |> Iter.to_list in \
     List.length l = n && List.for_all (fun (_,b) -> b) l)
 *)
 
@@ -530,18 +530,18 @@ let selecti bv arr =
     |> List.sort CCOrd.compare)
 *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 
-let to_seq bv k = iter_true bv k
+let to_iter bv k = iter_true bv k
 
 (*$Q
   Q.(small_int) (fun i -> \
       let i = max 1 i in \
       let bv = create ~size:i true in \
-      i = (to_seq bv |> Iter.length))
+      i = (to_iter bv |> Iter.length))
 *)
 
-let of_seq seq =
+let of_iter seq =
   let l = ref [] and maxi = ref 0 in
   seq (fun x -> l := x :: !l; maxi := max !maxi x);
   let bv = create ~size:(!maxi+1) false in
@@ -549,7 +549,7 @@ let of_seq seq =
   bv
 
 (*$T
-  CCList.range 0 10 |> CCList.to_iter |> of_seq |> to_seq \
+  CCList.range 0 10 |> CCList.to_iter |> of_iter |> to_iter \
     |> CCList.of_iter |> List.sort CCOrd.compare = CCList.range 0 10
 *)
 
diff --git a/src/data/CCBV.mli b/src/data/CCBV.mli
index d6c60609..140b8b1c 100644
--- a/src/data/CCBV.mli
+++ b/src/data/CCBV.mli
@@ -135,10 +135,10 @@ val select : t -> 'a array -> 'a list
 val selecti : t -> 'a array -> ('a * int) list
 (** Same as {!select}, but selected elements are paired with their indexes. *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 
-val to_seq : t -> int sequence
-val of_seq : int sequence -> t
+val to_iter : t -> int iter
+val of_iter : int iter -> t
 
 val pp : Format.formatter -> t -> unit
 (** Print the bitvector as a string of bits.
diff --git a/src/data/CCBijection.ml b/src/data/CCBijection.ml
index 3b2b1e3b..97aef425 100644
--- a/src/data/CCBijection.ml
+++ b/src/data/CCBijection.ml
@@ -2,7 +2,7 @@
 
 (** {1 Bijection} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 
 module type OrderedType = sig
   type t
@@ -30,9 +30,9 @@ module type S = sig
   val remove_right : right -> t -> t
   val list_left : t -> (left * right) list
   val list_right : t -> (right * left) list
-  val add_seq : (left * right) sequence -> t -> t
-  val of_seq : (left * right) sequence -> t
-  val to_seq : t -> (left * right) sequence
+  val add_iter : (left * right) iter -> t -> t
+  val of_iter : (left * right) iter -> t
+  val to_iter : t -> (left * right) iter
   val add_list : (left * right) list -> t -> t
   val of_list : (left * right) list -> t
   val to_list : t -> (left * right) list
@@ -108,14 +108,14 @@ module Make(L : OrderedType)(R : OrderedType) = struct
   let of_list l = add_list l empty
   let to_list = list_left
 
-  let add_seq seq m =
+  let add_iter seq m =
     let m = ref m in
     seq (fun (k,v) -> m := add k v !m);
     !m
 
-  let of_seq l = add_seq l empty
+  let of_iter l = add_iter l empty
 
-  let to_seq m yield = MapL.iter (fun k v -> yield (k,v)) m.left
+  let to_iter m yield = MapL.iter (fun k v -> yield (k,v)) m.left
 end
 
 (*$inject
diff --git a/src/data/CCBijection.mli b/src/data/CCBijection.mli
index d0907bfd..45372bf2 100644
--- a/src/data/CCBijection.mli
+++ b/src/data/CCBijection.mli
@@ -6,7 +6,7 @@
 
     @since 2.1 *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 
 module type OrderedType = sig
   type t
@@ -67,11 +67,11 @@ module type S = sig
   val list_right : t -> (right * left) list
   (** Return the bindings as a list of [(right, left)] values. *)
 
-  val add_seq : (left * right) sequence -> t -> t
+  val add_iter : (left * right) iter -> t -> t
 
-  val of_seq : (left * right) sequence -> t
+  val of_iter : (left * right) iter -> t
 
-  val to_seq : t -> (left * right) sequence
+  val to_iter : t -> (left * right) iter
 
   val add_list : (left * right) list -> t -> t
 
diff --git a/src/data/CCDeque.ml b/src/data/CCDeque.ml
index a77b14b0..23bbabab 100644
--- a/src/data/CCDeque.ml
+++ b/src/data/CCDeque.ml
@@ -34,9 +34,9 @@ type 'a t = {
 
 (*$R
   let q = create () in
-  add_seq_back q Iter.(3 -- 5);
+  add_iter_back q Iter.(3 -- 5);
   assert_equal [3;4;5] (to_list q);
-  add_seq_front q Iter.(of_list [2;1]);
+  add_iter_front q Iter.(of_list [2;1]);
   assert_equal [1;2;3;4;5] (to_list q);
   push_front q 0;
   assert_equal [0;1;2;3;4;5] (to_list q);
@@ -56,7 +56,7 @@ let clear q =
   ()
 
 (*$R
-  let q = of_seq Iter.(1 -- 100) in
+  let q = of_iter Iter.(1 -- 100) in
   assert_equal 100 (length q);
   clear q;
   assert_equal 0 (length q);
@@ -127,7 +127,7 @@ let peek_front d = match peek_front_opt d with
 *)
 
 (*$R
-  let d = of_seq Iter.(1 -- 10) in
+  let d = of_iter Iter.(1 -- 10) in
   let printer = pint in
   OUnit.assert_equal ~printer 1 (peek_front d);
   push_front d 42;
@@ -157,7 +157,7 @@ let peek_back d = match peek_back_opt d with
 *)
 
 (*$R
-  let d = of_seq Iter.(1 -- 10) in
+  let d = of_iter Iter.(1 -- 10) in
   let printer = pint in
   OUnit.assert_equal ~printer 1 (peek_front d);
   push_back d 42;
@@ -362,7 +362,7 @@ let iter f d =
 *)
 
 (*$R
-  let d = of_seq Iter.(1 -- 5) in
+  let d = of_iter Iter.(1 -- 5) in
   let s = Iter.from_iter (fun k -> iter k d) in
   let l = Iter.to_list s in
   OUnit.assert_equal ~printer:plist [1;2;3;4;5] l;
@@ -410,35 +410,35 @@ let length d = d.size
 *)
 
 (*$R
-  let d = of_seq Iter.(1 -- 10) in
+  let d = of_iter Iter.(1 -- 10) in
   OUnit.assert_equal ~printer:pint 10 (length d)
 *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 
-let add_seq_back q seq = seq (fun x -> push_back q x)
+let add_iter_back q seq = seq (fun x -> push_back q x)
 
-let add_seq_front q seq = seq (fun x -> push_front q x)
+let add_iter_front q seq = seq (fun x -> push_front q x)
 
 (*$R
   let q = of_list [4;5] in
-  add_seq_front q Iter.(of_list [3;2;1]);
+  add_iter_front q Iter.(of_list [3;2;1]);
   assert_equal [1;2;3;4;5] (to_list q);
-  add_seq_back q Iter.(of_list [6;7]);
+  add_iter_back q Iter.(of_list [6;7]);
   assert_equal [1;2;3;4;5;6;7] (to_list q);
 *)
 
-let of_seq seq =
+let of_iter seq =
   let deque = create () in
   seq (fun x -> push_back deque x);
   deque
 
-let to_seq d k = iter k d
+let to_iter d k = iter k d
 
 (*$Q
   Q.(list int) (fun l -> \
-    Iter.of_list l |> of_seq |> to_seq |> Iter.to_list = l)
+    Iter.of_list l |> of_iter |> to_iter |> Iter.to_list = l)
 *)
 
 let of_list l =
diff --git a/src/data/CCDeque.mli b/src/data/CCDeque.mli
index c617c94d..48a8adeb 100644
--- a/src/data/CCDeque.mli
+++ b/src/data/CCDeque.mli
@@ -113,14 +113,14 @@ val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
 (** {2 Conversions} *)
 
 type 'a gen = unit -> 'a option
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 
-val of_seq : 'a sequence -> 'a t
+val of_iter : 'a iter -> 'a t
 (** Create a deque from the sequence.
-    Optional argument [deque] disappears, use {!add_seq_back} instead.
+    Optional argument [deque] disappears, use {!add_iter_back} instead.
     @since 0.13 *)
 
-val to_seq : 'a t -> 'a sequence
+val to_iter : 'a t -> 'a iter
 (** Iterate on the elements. *)
 
 val of_gen : 'a gen -> 'a t
@@ -131,14 +131,14 @@ val to_gen : 'a t -> 'a gen
 (** Iterate on the elements of the deque.
     @since 0.13 *)
 
-val add_seq_front : 'a t -> 'a sequence -> unit
-(** [add_seq_front q seq] adds elements of [seq] into the front of [q],
+val add_iter_front : 'a t -> 'a iter -> unit
+(** [add_iter_front q seq] adds elements of [seq] into the front of [q],
     in reverse order.
     [O(n)] in time, where [n] is the number of elements to add.
     @since 0.13 *)
 
-val add_seq_back : 'a t -> 'a sequence -> unit
-(** [add_seq_back q seq] adds elements of [seq] into the back of [q],
+val add_iter_back : 'a t -> 'a iter -> unit
+(** [add_iter_back q seq] adds elements of [seq] into the back of [q],
     in order.
     [O(n)] in time, where [n] is the number of elements to add.
     @since 0.13 *)
diff --git a/src/data/CCFun_vec.ml b/src/data/CCFun_vec.ml
index 93d6822c..ddd62f0d 100644
--- a/src/data/CCFun_vec.ml
+++ b/src/data/CCFun_vec.ml
@@ -13,7 +13,7 @@
 
 (** {1 Hash Tries} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 type 'a printer = Format.formatter -> 'a -> unit
 type 'a ktree = unit -> [`Nil | `Node of 'a * 'a ktree list]
@@ -334,19 +334,19 @@ let to_list m = fold_rev m ~f:(fun acc x -> x::acc) ~x:[]
     l = to_list (of_list l))
 *)
 
-let add_seq v seq =
+let add_iter v seq =
   let v = ref v in
   seq (fun x -> v := push x !v);
   !v
 
-let of_seq s = add_seq empty s
+let of_iter s = add_iter empty s
 
-let to_seq m yield = iteri ~f:(fun _ v -> yield v) m
+let to_iter m yield = iteri ~f:(fun _ v -> yield v) m
 
 (*$Q
   _listuniq (fun l -> \
     (List.sort Stdlib.compare l) = \
-      (l |> Iter.of_list |> of_seq |> to_seq |> Iter.to_list \
+      (l |> Iter.of_list |> of_iter |> to_iter |> Iter.to_list \
         |> List.sort Stdlib.compare) )
 *)
 
diff --git a/src/data/CCFun_vec.mli b/src/data/CCFun_vec.mli
index 7368660b..fd075417 100644
--- a/src/data/CCFun_vec.mli
+++ b/src/data/CCFun_vec.mli
@@ -10,7 +10,7 @@
     @since 2.1
 *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 type 'a printer = Format.formatter -> 'a -> unit
 type 'a ktree = unit -> [`Nil | `Node of 'a * 'a ktree list]
@@ -118,11 +118,11 @@ val of_list : 'a list -> 'a t
 
 val add_list : 'a t -> 'a list -> 'a t
 
-val add_seq : 'a t -> 'a sequence -> 'a t
+val add_iter : 'a t -> 'a iter -> 'a t
 
-val of_seq : 'a sequence -> 'a t
+val of_iter : 'a iter -> 'a t
 
-val to_seq : 'a t -> 'a sequence
+val to_iter : 'a t -> 'a iter
 
 val add_gen : 'a t -> 'a gen -> 'a t
 
@@ -135,7 +135,7 @@ val to_gen : 'a t -> 'a gen
    val add_list_mut : id:Transient.t -> 'a t -> 'a list -> 'a t
    (** @raise Frozen if the ID is frozen. *)
 
-   val add_seq_mut : id:Transient.t -> 'a t -> 'a sequence -> 'a t
+   val add_iter_mut : id:Transient.t -> 'a t -> 'a iter -> 'a t
    (** @raise Frozen if the ID is frozen. *)
 
    val add_gen_mut : id:Transient.t -> 'a t -> 'a gen -> 'a t
diff --git a/src/data/CCGraph.ml b/src/data/CCGraph.ml
index 0b9fca31..394ca3dc 100644
--- a/src/data/CCGraph.ml
+++ b/src/data/CCGraph.ml
@@ -13,16 +13,6 @@ type 'a iter_once = 'a iter
 (** Iter that should be used only once
     @since 2.8 *)
 
-type 'a sequence = ('a -> unit) -> unit
-(** A sequence of items of type ['a], possibly infinite
-    @deprecate see {!iter} instead *)
-[@@ocaml.deprecated "see iter"]
-
-type 'a sequence_once = 'a iter
-(** Iter that should be used only once
-    @deprecate see {!iter_once} instead *)
-[@@ocaml.deprecated "see iter_once"]
-
 exception Iter_once
 
 let (|>) x f = f x
@@ -706,15 +696,6 @@ module type MAP = sig
 
   val to_iter : 'a t -> (vertex * 'a * vertex) iter
   (** @since 2.8 *)
-
-  val of_seq : (vertex * 'a * vertex) iter -> 'a t
-  (** @deprecated use {!of_iter} instead *)
-
-  val add_seq : (vertex * 'a * vertex) iter -> 'a t -> 'a t
-  (** @deprecated use {!add_iter} instead *)
-
-  val to_seq : 'a t -> (vertex * 'a * vertex) iter
-  (** @deprecated use {!to_iter} instead *)
 end
 
 module Map(O : Map.OrderedType) : MAP with type vertex = O.t = struct
@@ -787,10 +768,6 @@ module Map(O : Map.OrderedType) : MAP with type vertex = O.t = struct
   let of_iter iter = add_iter iter empty
 
   let to_iter m k = M.iter (fun v map -> M.iter (fun v' e -> k(v,e,v')) map) m
-
-  let add_seq = add_iter
-  let of_seq = of_iter
-  let to_seq = to_iter
 end
 
 (** {2 Misc} *)
diff --git a/src/data/CCGraph.mli b/src/data/CCGraph.mli
index 557fa7e6..61c4fc1b 100644
--- a/src/data/CCGraph.mli
+++ b/src/data/CCGraph.mli
@@ -35,16 +35,6 @@ type 'a iter_once = 'a iter
 (** Iter that should be used only once
     @since 2.8 *)
 
-type 'a sequence = ('a -> unit) -> unit
-(** A sequence of items of type ['a], possibly infinite
-    @deprecate see {!iter} instead *)
-[@@ocaml.deprecated "see iter"]
-
-type 'a sequence_once = 'a iter
-(** Iter that should be used only once
-    @deprecate see {!iter_once} instead *)
-[@@ocaml.deprecated "see iter_once"]
-
 exception Iter_once
 (** Raised when a sequence meant to be used once is used several times. *)
 
@@ -428,15 +418,6 @@ module type MAP = sig
 
   val to_iter : 'a t -> (vertex * 'a * vertex) iter
   (** @since 2.8 *)
-
-  val of_seq : (vertex * 'a * vertex) iter -> 'a t
-  (** @deprecated use {!of_iter} instead *)
-
-  val add_seq : (vertex * 'a * vertex) iter -> 'a t -> 'a t
-  (** @deprecated use {!add_iter} instead *)
-
-  val to_seq : 'a t -> (vertex * 'a * vertex) iter
-  (** @deprecated use {!to_iter} instead *)
 end
 
 module Map(O : Map.OrderedType) : MAP with type vertex = O.t
diff --git a/src/data/CCHashSet.ml b/src/data/CCHashSet.ml
index 38bf6542..a120661f 100644
--- a/src/data/CCHashSet.ml
+++ b/src/data/CCHashSet.ml
@@ -2,7 +2,7 @@
 
 (** {1 Mutable Set} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a printer = Format.formatter -> 'a -> unit
 
 module type S = sig
@@ -79,11 +79,11 @@ module type S = sig
 
   val of_list : elt list -> t
 
-  val to_seq : t -> elt sequence
+  val to_iter : t -> elt iter
 
-  val of_seq : elt sequence -> t
+  val of_iter : elt iter -> t
 
-  val add_seq : t -> elt sequence -> unit
+  val add_iter : t -> elt iter -> unit
 
   val pp : ?sep:string -> elt printer -> t printer
   (** [pp pp_elt] returns a set printer, given a printer for
@@ -212,11 +212,11 @@ module Make(E : ELEMENT) : S with type elt = E.t = struct
     List.iter (insert res) l;
     res
 
-  let to_seq s yield = iter yield s
+  let to_iter s yield = iter yield s
 
-  let add_seq s seq = seq (insert s)
+  let add_iter s seq = seq (insert s)
 
-  let of_seq seq =
+  let of_iter seq =
     let s = create 32 in
     seq (insert s);
     s
diff --git a/src/data/CCHashSet.mli b/src/data/CCHashSet.mli
index d009ea04..b0dd376a 100644
--- a/src/data/CCHashSet.mli
+++ b/src/data/CCHashSet.mli
@@ -6,7 +6,7 @@
 
     @since 0.13 *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a printer = Format.formatter -> 'a -> unit
 
 module type S = sig
@@ -83,11 +83,11 @@ module type S = sig
 
   val of_list : elt list -> t
 
-  val to_seq : t -> elt sequence
+  val to_iter : t -> elt iter
 
-  val of_seq : elt sequence -> t
+  val of_iter : elt iter -> t
 
-  val add_seq : t -> elt sequence -> unit
+  val add_iter : t -> elt iter -> unit
 
   val pp : ?sep:string -> elt printer -> t printer
   (** [pp pp_elt] returns a set printer, given a printer for
diff --git a/src/data/CCHashTrie.ml b/src/data/CCHashTrie.ml
index dc34ed04..3ee9cdde 100644
--- a/src/data/CCHashTrie.ml
+++ b/src/data/CCHashTrie.ml
@@ -14,7 +14,7 @@
 
 (** {1 Hash Tries} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 type 'a printer = Format.formatter -> 'a -> unit
 type 'a ktree = unit -> [`Nil | `Node of 'a * 'a ktree list]
@@ -105,14 +105,14 @@ module type S = sig
 
   val of_list : (key * 'a) list -> 'a t
 
-  val add_seq : 'a t -> (key * 'a) sequence -> 'a t
+  val add_iter : 'a t -> (key * 'a) iter -> 'a t
 
-  val add_seq_mut : id:Transient.t -> 'a t -> (key * 'a) sequence -> 'a t
+  val add_iter_mut : id:Transient.t -> 'a t -> (key * 'a) iter -> 'a t
   (** @raise Frozen if the ID is frozen *)
 
-  val of_seq : (key * 'a) sequence -> 'a t
+  val of_iter : (key * 'a) iter -> 'a t
 
-  val to_seq : 'a t -> (key * 'a) sequence
+  val to_iter : 'a t -> (key * 'a) iter
 
   val add_gen : 'a t -> (key * 'a) gen -> 'a t
 
@@ -658,22 +658,22 @@ module Make(Key : KEY)
 
   let of_list l = add_list empty l
 
-  let add_seq_mut ~id m seq =
+  let add_iter_mut ~id m seq =
     let m = ref m in
     seq (fun (k,v) -> m := add_mut ~id k v !m);
     !m
 
-  let add_seq m seq =
-    Transient.with_ (fun id -> add_seq_mut ~id m seq)
+  let add_iter m seq =
+    Transient.with_ (fun id -> add_iter_mut ~id m seq)
 
-  let of_seq s = add_seq empty s
+  let of_iter s = add_iter empty s
 
-  let to_seq m yield = iter ~f:(fun k v -> yield (k,v)) m
+  let to_iter m yield = iter ~f:(fun k v -> yield (k,v)) m
 
   (*$Q
     _listuniq (fun l -> \
       (List.sort Stdlib.compare l) = \
-        (l |> Iter.of_list |> M.of_seq |> M.to_seq |> Iter.to_list \
+        (l |> Iter.of_list |> M.of_iter |> M.to_iter |> Iter.to_list \
           |> List.sort Stdlib.compare) )
   *)
 
diff --git a/src/data/CCHashTrie.mli b/src/data/CCHashTrie.mli
index 2fb1a728..5efe620e 100644
--- a/src/data/CCHashTrie.mli
+++ b/src/data/CCHashTrie.mli
@@ -15,7 +15,7 @@
     @since 0.13
 *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 type 'a printer = Format.formatter -> 'a -> unit
 type 'a ktree = unit -> [`Nil | `Node of 'a * 'a ktree list]
@@ -118,14 +118,14 @@ module type S = sig
 
   val of_list : (key * 'a) list -> 'a t
 
-  val add_seq : 'a t -> (key * 'a) sequence -> 'a t
+  val add_iter : 'a t -> (key * 'a) iter -> 'a t
 
-  val add_seq_mut : id:Transient.t -> 'a t -> (key * 'a) sequence -> 'a t
+  val add_iter_mut : id:Transient.t -> 'a t -> (key * 'a) iter -> 'a t
   (** @raise Frozen if the ID is frozen. *)
 
-  val of_seq : (key * 'a) sequence -> 'a t
+  val of_iter : (key * 'a) iter -> 'a t
 
-  val to_seq : 'a t -> (key * 'a) sequence
+  val to_iter : 'a t -> (key * 'a) iter
 
   val add_gen : 'a t -> (key * 'a) gen -> 'a t
 
diff --git a/src/data/CCHet.ml b/src/data/CCHet.ml
index abd9ec0e..3d9538af 100644
--- a/src/data/CCHet.ml
+++ b/src/data/CCHet.ml
@@ -34,7 +34,7 @@
 
 *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 
 module type KEY_IMPL = sig
@@ -117,22 +117,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
 
@@ -182,18 +182,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
diff --git a/src/data/CCHet.mli b/src/data/CCHet.mli
index 3dc1a5f3..c578c00c 100644
--- a/src/data/CCHet.mli
+++ b/src/data/CCHet.mli
@@ -8,7 +8,7 @@
 
     @since 0.17 *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 
 module Key : sig
@@ -44,11 +44,11 @@ module Tbl : sig
 
   val iter : (pair -> unit) -> t -> unit
 
-  val to_seq : t -> pair sequence
+  val to_iter : t -> pair iter
 
-  val of_seq : pair sequence -> t
+  val of_iter : pair iter -> t
 
-  val add_seq : t -> pair sequence -> unit
+  val add_iter : t -> pair iter -> unit
 
   val add_list : t -> pair list -> unit
 
@@ -80,11 +80,11 @@ module Map : sig
 
   val iter : (pair -> unit) -> t -> unit
 
-  val to_seq : t -> pair sequence
+  val to_iter : t -> pair iter
 
-  val of_seq : pair sequence -> t
+  val of_iter : pair iter -> t
 
-  val add_seq : t -> pair sequence -> t
+  val add_iter : t -> pair iter -> t
 
   val add_list : t -> pair list -> t
 
diff --git a/src/data/CCImmutArray.ml b/src/data/CCImmutArray.ml
index 32c601ad..86144911 100644
--- a/src/data/CCImmutArray.ml
+++ b/src/data/CCImmutArray.ml
@@ -69,7 +69,7 @@ let exists p a =
 
 (** {2 Conversions} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 
 let of_list = Array.of_list
@@ -78,9 +78,9 @@ let to_list = Array.to_list
 
 let of_array_unsafe a = a (* careful with that axe, Eugene *)
 
-let to_seq a k = iter k a
+let to_iter a k = iter k a
 
-let of_seq s =
+let of_iter s =
   let l = ref [] in
   s (fun x -> l := x :: !l);
   Array.of_list (List.rev !l)
@@ -88,7 +88,7 @@ let of_seq s =
 (*$Q
   Q.(list int) (fun l -> \
     let g = Iter.of_list l in \
-    of_seq g |> to_seq |> Iter.to_list = l)
+    of_iter g |> to_iter |> Iter.to_list = l)
 *)
 
 let rec gen_to_list_ acc g = match g() with
diff --git a/src/data/CCImmutArray.mli b/src/data/CCImmutArray.mli
index 0383cfa0..b9bceb78 100644
--- a/src/data/CCImmutArray.mli
+++ b/src/data/CCImmutArray.mli
@@ -65,7 +65,7 @@ val exists : ('a -> bool) -> 'a t -> bool
 
 (** {2 Conversions} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 
 val of_list : 'a list -> 'a t
@@ -76,9 +76,9 @@ val of_array_unsafe : 'a array -> 'a t
 (** Take ownership of the given array. Careful, the array must {b NOT}
     be modified afterwards! *)
 
-val to_seq : 'a t -> 'a sequence
+val to_iter : 'a t -> 'a iter
 
-val of_seq : 'a sequence -> 'a t
+val of_iter : 'a iter -> 'a t
 
 val of_gen : 'a gen -> 'a t
 
diff --git a/src/data/CCKTree.ml b/src/data/CCKTree.ml
index 1ae2d9e2..b09a6d67 100644
--- a/src/data/CCKTree.ml
+++ b/src/data/CCKTree.ml
@@ -5,7 +5,7 @@
     graphs (as infinite trees) in a lazy fashion. Like {!CCKList}, it
     is a structural type. *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 type 'a printer = Format.formatter -> 'a -> unit
 
diff --git a/src/data/CCKTree.mli b/src/data/CCKTree.mli
index 9907e19d..0e517dcd 100644
--- a/src/data/CCKTree.mli
+++ b/src/data/CCKTree.mli
@@ -5,7 +5,7 @@
     graphs (as infinite trees) in a lazy fashion. Like {!CCKList}, it
     is a structural type. *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 type 'a printer = Format.formatter -> 'a -> unit
 
diff --git a/src/data/CCMixmap.ml b/src/data/CCMixmap.ml
index 616aca2b..10befe19 100644
--- a/src/data/CCMixmap.ml
+++ b/src/data/CCMixmap.ml
@@ -79,18 +79,18 @@ module type S = sig
 
   (** {2 Iterators} *)
 
-  type 'a sequence = ('a -> unit) -> unit
+  type 'a iter = ('a -> unit) -> unit
 
-  val keys_seq : t -> key sequence
+  val keys_iter : t -> key iter
   (** All the keys *)
 
-  val bindings_of : inj:'a injection -> t -> (key * 'a) sequence
+  val bindings_of : inj:'a injection -> t -> (key * 'a) iter
   (** All the bindings that come from the corresponding injection *)
 
   type value =
     | Value : ('a injection -> 'a option) -> value
 
-  val bindings : t -> (key * value) sequence
+  val bindings : t -> (key * value) iter
   (** Iterate on all bindings *)
 end
 
@@ -140,9 +140,9 @@ module Make(X : ORD) : S with type key = X.t = struct
 
   (** {2 Iterators} *)
 
-  type 'a sequence = ('a -> unit) -> unit
+  type 'a iter = ('a -> unit) -> unit
 
-  let keys_seq map yield =
+  let keys_iter map yield =
     M.iter
       (fun x _ -> yield x)
       map
diff --git a/src/data/CCMixmap.mli b/src/data/CCMixmap.mli
index 7eb488d7..b854b27e 100644
--- a/src/data/CCMixmap.mli
+++ b/src/data/CCMixmap.mli
@@ -81,18 +81,18 @@ module type S = sig
 
   (** {2 Iterators} *)
 
-  type 'a sequence = ('a -> unit) -> unit
+  type 'a iter = ('a -> unit) -> unit
 
-  val keys_seq : t -> key sequence
+  val keys_iter : t -> key iter
   (** All the keys. *)
 
-  val bindings_of : inj:'a injection -> t -> (key * 'a) sequence
+  val bindings_of : inj:'a injection -> t -> (key * 'a) iter
   (** All the bindings that come from the corresponding injection. *)
 
   type value =
     | Value : ('a injection -> 'a option) -> value
 
-  val bindings : t -> (key * value) sequence
+  val bindings : t -> (key * value) iter
   (** Iterate on all bindings. *)
 end
 
diff --git a/src/data/CCMixtbl.ml b/src/data/CCMixtbl.ml
index 7006feba..c9851355 100644
--- a/src/data/CCMixtbl.ml
+++ b/src/data/CCMixtbl.ml
@@ -121,9 +121,9 @@ let fold_keys tbl acc f =
 
 (** {2 Iterators} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 
-let keys_seq tbl yield =
+let keys_iter tbl yield =
   Hashtbl.iter
     (fun x _ -> yield x)
     tbl
@@ -135,7 +135,7 @@ let keys_seq tbl yield =
   set ~inj:inj_int tbl "foo" 1;
   set ~inj:inj_int tbl "bar" 2;
   set ~inj:inj_str tbl "baaz" "hello";
-  let l = keys_seq tbl |> Iter.to_list in
+  let l = keys_iter tbl |> Iter.to_list in
   OUnit.assert_equal ["baaz"; "bar"; "foo"] (List.sort compare l);
 *)
 
diff --git a/src/data/CCMixtbl.mli b/src/data/CCMixtbl.mli
index 099d3090..cf67d85d 100644
--- a/src/data/CCMixtbl.mli
+++ b/src/data/CCMixtbl.mli
@@ -86,16 +86,16 @@ val fold_keys : 'a t -> 'b -> ('b -> 'a -> 'b) -> 'b
 
 (** {2 Iterators} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 
-val keys_seq : 'a t -> 'a sequence
+val keys_iter : 'a t -> 'a iter
 (** All the keys. *)
 
-val bindings_of : inj:'b injection -> 'a t -> ('a * 'b) sequence
+val bindings_of : inj:'b injection -> 'a t -> ('a * 'b) iter
 (** All the bindings that come from the corresponding injection. *)
 
 type value =
   | Value : ('b injection -> 'b option) -> value
 
-val bindings : 'a t -> ('a *  value) sequence
+val bindings : 'a t -> ('a *  value) iter
 (** Iterate on all bindings. *)
diff --git a/src/data/CCMultiMap.ml b/src/data/CCMultiMap.ml
index 8c6ab6f0..fb6fb6d7 100644
--- a/src/data/CCMultiMap.ml
+++ b/src/data/CCMultiMap.ml
@@ -2,7 +2,7 @@
 
 (** {1 Multimap} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 
 module type S = sig
   type key
@@ -64,13 +64,13 @@ module type S = sig
   val submap : t -> t -> bool
   (** [submap m1 m2] is true iff all bindings of [m1] are also in [m2] *)
 
-  val to_seq : t -> (key * value) sequence
+  val to_iter : t -> (key * value) iter
 
-  val of_seq : ?init:t -> (key * value) sequence -> t
+  val of_iter : ?init:t -> (key * value) iter -> t
 
-  val keys : t -> key sequence
+  val keys : t -> key iter
 
-  val values : t -> value sequence
+  val values : t -> value iter
   (** Some values may occur several times *)
 end
 
@@ -190,9 +190,9 @@ module Make(K : OrderedType)(V : OrderedType) = struct
            false)
       m1
 
-  let to_seq m k = iter m (fun x y -> k (x,y))
+  let to_iter m k = iter m (fun x y -> k (x,y))
 
-  let of_seq ?(init=empty) seq =
+  let of_iter ?(init=empty) seq =
     let m = ref init in
     seq (fun (k,v) -> m := add !m k v);
     !m
@@ -235,10 +235,10 @@ module type BIDIR = sig
   val mem_right : t -> right -> bool
   (** Is the right key present in at least one pair? *)
 
-  val find_left : t -> left -> right sequence
+  val find_left : t -> left -> right iter
   (** Find all bindings for this given left-key *)
 
-  val find_right : t -> right -> left sequence
+  val find_right : t -> right -> left iter
   (** Find all bindings for this given right-key *)
 
   val find1_left : t -> left -> right option
@@ -250,22 +250,22 @@ module type BIDIR = sig
   val fold : ('a -> left -> right -> 'a) -> 'a -> t -> 'a
   (** Fold on pairs *)
 
-  val pairs : t -> (left * right) sequence
+  val pairs : t -> (left * right) iter
   (** Iterate on pairs *)
 
-  val add_pairs : t -> (left * right) sequence -> t
+  val add_pairs : t -> (left * right) iter -> t
   (** Add pairs *)
 
-  val seq_left : t -> left sequence
-  val seq_right : t -> right sequence
+  val iter_left : t -> left iter
+  val iter_right : t -> right iter
 end
 
-let _fold_seq f acc seq =
+let _fold_iter f acc seq =
   let acc = ref acc in
   seq (fun x -> acc := f !acc x);
   !acc
 
-let _head_seq seq =
+let _head_iter seq =
   let r = ref None in
   begin try seq (fun x -> r := Some x; raise Exit)
     with Exit -> ();
@@ -308,29 +308,29 @@ module MakeBidir(L : OrderedType)(R : OrderedType) = struct
   let find_right m b = MapR.find_iter m.right b
 
   let remove_left m a =
-    _fold_seq
+    _fold_iter
       (fun m b -> remove m a b)
       m (find_left m a)
 
   let remove_right m b =
-    _fold_seq
+    _fold_iter
       (fun m a -> remove m a b)
       m (find_right m b)
 
   let mem_left m a = MapL.mem m.left a
   let mem_right m b = MapR.mem m.right b
 
-  let find1_left m a = _head_seq (find_left m a)
-  let find1_right m b = _head_seq (find_right m b)
+  let find1_left m a = _head_iter (find_left m a)
+  let find1_right m b = _head_iter (find_right m b)
 
   let fold f acc m =
     MapL.fold m.left acc f
 
-  let pairs m = MapL.to_seq m.left
+  let pairs m = MapL.to_iter m.left
 
-  let add_pairs m seq = _fold_seq (fun m (a,b) -> add m a b) m seq
+  let add_pairs m seq = _fold_iter (fun m (a,b) -> add m a b) m seq
 
-  let seq_left m = MapL.keys m.left
+  let iter_left m = MapL.keys m.left
 
-  let seq_right m = MapR.keys m.right
+  let iter_right m = MapR.keys m.right
 end
diff --git a/src/data/CCMultiMap.mli b/src/data/CCMultiMap.mli
index 556e9794..007bd41b 100644
--- a/src/data/CCMultiMap.mli
+++ b/src/data/CCMultiMap.mli
@@ -2,7 +2,7 @@
 
 (** {1 Multimap} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 
 module type S = sig
   type key
@@ -64,13 +64,13 @@ module type S = sig
   val submap : t -> t -> bool
   (** [submap m1 m2] is [true] iff all bindings of [m1] are also in [m2]. *)
 
-  val to_seq : t -> (key * value) sequence
+  val to_iter : t -> (key * value) iter
 
-  val of_seq : ?init:t -> (key * value) sequence -> t
+  val of_iter : ?init:t -> (key * value) iter -> t
 
-  val keys : t -> key sequence
+  val keys : t -> key iter
 
-  val values : t -> value sequence
+  val values : t -> value iter
   (** Some values may occur several times. *)
 end
 
@@ -120,10 +120,10 @@ module type BIDIR = sig
   val mem_right : t -> right -> bool
   (** Is the right key present in at least one pair? *)
 
-  val find_left : t -> left -> right sequence
+  val find_left : t -> left -> right iter
   (** Find all bindings for this given left-key. *)
 
-  val find_right : t -> right -> left sequence
+  val find_right : t -> right -> left iter
   (** Find all bindings for this given right-key. *)
 
   val find1_left : t -> left -> right option
@@ -135,14 +135,14 @@ module type BIDIR = sig
   val fold : ('a -> left -> right -> 'a) -> 'a -> t -> 'a
   (** Fold on pairs. *)
 
-  val pairs : t -> (left * right) sequence
+  val pairs : t -> (left * right) iter
   (** Iterate on pairs. *)
 
-  val add_pairs : t -> (left * right) sequence -> t
+  val add_pairs : t -> (left * right) iter -> t
   (** Add pairs. *)
 
-  val seq_left : t -> left sequence
-  val seq_right : t -> right sequence
+  val iter_left : t -> left iter
+  val iter_right : t -> right iter
 end
 
 module MakeBidir(L : OrderedType)(R : OrderedType) : BIDIR
diff --git a/src/data/CCMultiSet.ml b/src/data/CCMultiSet.ml
index 9e9a01cb..b6bc318e 100644
--- a/src/data/CCMultiSet.ml
+++ b/src/data/CCMultiSet.ml
@@ -3,7 +3,7 @@
 
 (** {1 Multiset} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 
 let max_int = max
 let min_int = min
@@ -87,9 +87,9 @@ module type S = sig
 
   val to_list : t -> elt list
 
-  val to_seq : t -> elt sequence
+  val to_iter : t -> elt iter
 
-  val of_seq : elt sequence -> t
+  val of_iter : elt iter -> t
 
   val of_list_mult : (elt * int) list -> t
   (** @since 0.19 *)
@@ -97,10 +97,10 @@ module type S = sig
   val to_list_mult : t -> (elt * int) list
   (** @since 0.19 *)
 
-  val to_seq_mult : t -> (elt * int) sequence
+  val to_iter_mult : t -> (elt * int) iter
   (** @since 0.19 *)
 
-  val of_seq_mult : (elt * int) sequence -> t
+  val of_iter_mult : (elt * int) iter -> t
   (** @since 0.19 *)
 end
 
@@ -235,10 +235,10 @@ module Make(O : Set.OrderedType) = struct
     in
     fold m [] (fun acc n x -> n_cons n x acc)
 
-  let to_seq m k =
+  let to_iter m k =
     M.iter (fun x n -> for _i = 1 to n do k x done) m
 
-  let of_seq seq =
+  let of_iter seq =
     let m = ref empty in
     seq (fun x -> m := add !m x);
     !m
@@ -251,9 +251,9 @@ module Make(O : Set.OrderedType) = struct
   let to_list_mult m =
     fold m [] (fun acc n x -> (x,n) :: acc)
 
-  let to_seq_mult m k = M.iter (fun x n -> k (x,n)) m
+  let to_iter_mult m k = M.iter (fun x n -> k (x,n)) m
 
-  let of_seq_mult seq =
+  let of_iter_mult seq =
     let m = ref empty in
     seq (fun (x,n) -> m := add_mult !m x n);
     !m
diff --git a/src/data/CCMultiSet.mli b/src/data/CCMultiSet.mli
index 053607e7..fd2f3146 100644
--- a/src/data/CCMultiSet.mli
+++ b/src/data/CCMultiSet.mli
@@ -3,7 +3,7 @@
 
 (** {1 Multiset} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 
 module type S = sig
   type elt
@@ -84,9 +84,9 @@ module type S = sig
 
   val to_list : t -> elt list
 
-  val to_seq : t -> elt sequence
+  val to_iter : t -> elt iter
 
-  val of_seq : elt sequence -> t
+  val of_iter : elt iter -> t
 
   val of_list_mult : (elt * int) list -> t
   (** @since 0.19 *)
@@ -94,10 +94,10 @@ module type S = sig
   val to_list_mult : t -> (elt * int) list
   (** @since 0.19 *)
 
-  val to_seq_mult : t -> (elt * int) sequence
+  val to_iter_mult : t -> (elt * int) iter
   (** @since 0.19 *)
 
-  val of_seq_mult : (elt * int) sequence -> t
+  val of_iter_mult : (elt * int) iter -> t
   (** @since 0.19 *)
 end
 
diff --git a/src/data/CCPersistentArray.ml b/src/data/CCPersistentArray.ml
index 749e3340..914bcea0 100644
--- a/src/data/CCPersistentArray.ml
+++ b/src/data/CCPersistentArray.ml
@@ -126,12 +126,12 @@ let of_rev_list l =
   rev_in_place_ a 0 ~len:(Array.length a);
   ref (Array a)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 
-let to_seq a yield = iter yield a
+let to_iter a yield = iter yield a
 
-let of_seq seq =
+let of_iter seq =
   let l = ref [] in
   seq (fun x -> l := x :: !l);
   of_rev_list !l
diff --git a/src/data/CCPersistentArray.mli b/src/data/CCPersistentArray.mli
index a325dff1..786f85d8 100644
--- a/src/data/CCPersistentArray.mli
+++ b/src/data/CCPersistentArray.mli
@@ -114,12 +114,12 @@ val of_rev_list : 'a list -> 'a t
 
 (** {2 Conversions} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 
-val to_seq : 'a t -> 'a sequence
+val to_iter : 'a t -> 'a iter
 
-val of_seq : 'a sequence -> 'a t
+val of_iter : 'a iter -> 'a t
 
 val of_gen : 'a gen -> 'a t
 (** @since 0.13 *)
diff --git a/src/data/CCPersistentHashtbl.ml b/src/data/CCPersistentHashtbl.ml
index a58a6cc9..af9ff54f 100644
--- a/src/data/CCPersistentHashtbl.ml
+++ b/src/data/CCPersistentHashtbl.ml
@@ -3,7 +3,7 @@
 
 (** {1 Persistent hash-table on top of OCaml's hashtables} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a printer = Format.formatter -> 'a -> unit
 type 'a equal = 'a -> 'a -> bool
 
@@ -92,16 +92,16 @@ module type S = sig
 
   (** {3 Conversions} *)
 
-  val of_seq : (key * 'a) sequence -> 'a t
+  val of_iter : (key * 'a) iter -> 'a t
   (** Add (replace) bindings from the sequence to the table *)
 
   val of_list : (key * 'a) list -> 'a t
 
-  val add_seq : 'a t -> (key * 'a) sequence -> 'a t
+  val add_iter : 'a t -> (key * 'a) iter -> 'a t
 
   val add_list : 'a t -> (key  * 'a) list -> 'a t
 
-  val to_seq : 'a t -> (key * 'a) sequence
+  val to_iter : 'a t -> (key * 'a) iter
   (** Iter of the bindings of the table *)
 
   val to_list : 'a t -> (key * 'a) list
@@ -127,7 +127,7 @@ end
       4, "d";
     ]
 
-  let my_seq = Iter.of_list my_list
+  let my_iter = Iter.of_list my_list
 
   let _list_uniq = CCList.sort_uniq
     ~cmp:(fun a b -> Stdlib.compare (fst a) (fst b))
@@ -222,7 +222,7 @@ module Make(H : HashedType) : S with type key = H.t = struct
                     if H.equal k k4 then v4 else find_rec_ k l4
 
   (*$R
-    let h = H.of_seq my_seq in
+    let h = H.of_iter my_iter in
     OUnit.assert_equal "a" (H.find h 1);
     OUnit.assert_raises Not_found (fun () -> H.find h 5);
     let h' = H.replace h 5 "e" in
@@ -235,7 +235,7 @@ module Make(H : HashedType) : S with type key = H.t = struct
   (*$R
     let n = 10000 in
     let seq = Iter.map (fun i -> i, string_of_int i) Iter.(0--n) in
-    let h = H.of_seq seq in
+    let h = H.of_iter seq in
     Iter.iter
       (fun (k,v) ->
         OUnit.assert_equal ~printer:(fun x -> x) v (H.find h k))
@@ -267,7 +267,7 @@ module Make(H : HashedType) : S with type key = H.t = struct
     with Not_found -> false
 
   (*$R
-    let h = H.of_seq
+    let h = H.of_iter
       Iter.(map (fun i -> i, string_of_int i)
         (0 -- 200)) in
     OUnit.assert_equal 201 (H.length h);
@@ -369,7 +369,7 @@ module Make(H : HashedType) : S with type key = H.t = struct
     )
 
   (*$R
-    let h = H.of_seq my_seq in
+    let h = H.of_iter my_iter in
     OUnit.assert_equal "a" (H.find h 1);
     OUnit.assert_raises Not_found (fun () -> H.find h 5);
     let h1 = H.add h 5 "e" in
@@ -413,7 +413,7 @@ module Make(H : HashedType) : S with type key = H.t = struct
             t'
 
   (*$R
-    let h = H.of_seq my_seq in
+    let h = H.of_iter my_iter in
     OUnit.assert_equal (H.find h 2) "b";
     OUnit.assert_equal (H.find h 3) "c";
     OUnit.assert_equal (H.find h 4) "d";
@@ -428,7 +428,7 @@ module Make(H : HashedType) : S with type key = H.t = struct
     let open Iter.Infix in
     let n = 10000 in
     let seq = Iter.map (fun i -> i, string_of_int i) (0 -- n) in
-    let h = H.of_seq seq in
+    let h = H.of_iter seq in
     OUnit.assert_equal (n+1) (H.length h);
     let h = Iter.fold (fun h i -> H.remove h i) h (0 -- 500) in
     OUnit.assert_equal (n-500) (H.length h);
@@ -574,15 +574,15 @@ module Make(H : HashedType) : S with type key = H.t = struct
     OUnit.assert_equal "c" (H.find t 3);
   *)
 
-  let add_seq init seq =
+  let add_iter init seq =
     let tbl = ref init in
     seq (fun (k,v) -> tbl := replace !tbl k v);
     !tbl
 
-  let of_seq seq = add_seq (empty ()) seq
+  let of_iter seq = add_iter (empty ()) seq
 
   let add_list init l =
-    add_seq init (fun k -> List.iter k l)
+    add_iter init (fun k -> List.iter k l)
 
   (*$QR
     _list_int_int (fun l ->
@@ -608,17 +608,17 @@ module Make(H : HashedType) : S with type key = H.t = struct
   let to_list t = fold (fun acc k v -> (k,v)::acc) [] t
 
   (*$R
-    let h = H.of_seq my_seq in
-    let l = Iter.to_list (H.to_seq h) in
+    let h = H.of_iter my_iter in
+    let l = Iter.to_list (H.to_iter h) in
     OUnit.assert_equal my_list (List.sort compare l)
   *)
 
-  let to_seq t =
+  let to_iter t =
     fun k ->
       iter t (fun x y -> k (x,y))
 
   (*$R
-    let h = H.of_seq my_seq in
+    let h = H.of_iter my_iter in
     OUnit.assert_equal "b" (H.find h 2);
     OUnit.assert_equal "a" (H.find h 1);
     OUnit.assert_raises Not_found (fun () -> H.find h 42);
diff --git a/src/data/CCPersistentHashtbl.mli b/src/data/CCPersistentHashtbl.mli
index 3deadf7d..d7af21d0 100644
--- a/src/data/CCPersistentHashtbl.mli
+++ b/src/data/CCPersistentHashtbl.mli
@@ -10,7 +10,7 @@
 
     This module is not thread-safe. *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a printer = Format.formatter -> 'a -> unit
 type 'a equal = 'a -> 'a -> bool
 
@@ -99,16 +99,16 @@ module type S = sig
 
   (** {3 Conversions} *)
 
-  val of_seq : (key * 'a) sequence -> 'a t
+  val of_iter : (key * 'a) iter -> 'a t
   (** Add (replace) bindings from the sequence to the table. *)
 
   val of_list : (key * 'a) list -> 'a t
 
-  val add_seq : 'a t -> (key * 'a) sequence -> 'a t
+  val add_iter : 'a t -> (key * 'a) iter -> 'a t
 
   val add_list : 'a t -> (key  * 'a) list -> 'a t
 
-  val to_seq : 'a t -> (key * 'a) sequence
+  val to_iter : 'a t -> (key * 'a) iter
   (** Iter of the bindings of the table. *)
 
   val to_list : 'a t -> (key * 'a) list
diff --git a/src/data/CCRAL.ml b/src/data/CCRAL.ml
index 2bc3353e..43594e6c 100644
--- a/src/data/CCRAL.ml
+++ b/src/data/CCRAL.ml
@@ -489,7 +489,7 @@ let range_r_open_ i j =
 
 (** {2 Conversions} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 
 let add_list l l2 = List.fold_left (fun acc x -> cons x acc) l (List.rev l2)
@@ -525,27 +525,27 @@ let to_array l = match l with
     of_array a |> to_array = a)
 *)
 
-let of_seq s =
+let of_iter s =
   let l = ref empty in
   s (fun x -> l := cons x !l);
   rev !l
 
-let add_seq l s =
+let add_iter l s =
   let l1 = ref empty in
   s (fun x -> l1 := cons x !l1);
   fold ~f:(fun acc x -> cons x acc) ~x:l !l1
 
-let to_seq l yield = iter ~f:yield l
+let to_iter l yield = iter ~f:yield l
 
 (*$Q & ~small:List.length
   Q.(list small_int) (fun l -> \
-    of_list l |> to_seq |> Iter.to_list = l)
+    of_list l |> to_iter |> Iter.to_list = l)
   Q.(list small_int) (fun l -> \
-    Iter.of_list l |> of_seq |> to_list = l)
+    Iter.of_list l |> of_iter |> to_list = l)
 *)
 
 (*$T
-  add_seq (of_list [3;4]) (Iter.of_list [1;2]) |> to_list = [1;2;3;4]
+  add_iter (of_list [3;4]) (Iter.of_list [1;2]) |> to_list = [1;2;3;4]
 *)
 
 let rec gen_iter_ f g = match g() with
diff --git a/src/data/CCRAL.mli b/src/data/CCRAL.mli
index 3d9721d3..1abdc2bb 100644
--- a/src/data/CCRAL.mli
+++ b/src/data/CCRAL.mli
@@ -126,7 +126,7 @@ val range : int -> int -> int t
 
 (** {2 Conversions} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a gen = unit -> 'a option
 
 val add_list : 'a t -> 'a list -> 'a t
@@ -146,11 +146,11 @@ val add_array : 'a t -> 'a array -> 'a t
 val to_array : 'a t -> 'a array
 (** More efficient than on usual lists. *)
 
-val add_seq : 'a t -> 'a sequence -> 'a t
+val add_iter : 'a t -> 'a iter -> 'a t
 
-val of_seq : 'a sequence -> 'a t
+val of_iter : 'a iter -> 'a t
 
-val to_seq : 'a t -> 'a sequence
+val to_iter : 'a t -> 'a iter
 
 val add_gen : 'a t -> 'a gen -> 'a t
 
diff --git a/src/data/CCSimple_queue.ml b/src/data/CCSimple_queue.ml
index 725048cb..13370846 100644
--- a/src/data/CCSimple_queue.ml
+++ b/src/data/CCSimple_queue.ml
@@ -4,7 +4,6 @@
 (** {1 Functional queues (fifo)} *)
 
 type 'a iter = ('a -> unit) -> unit
-type 'a sequence = ('a -> unit) -> unit
 type 'a printer = Format.formatter -> 'a -> unit
 type 'a gen = unit -> 'a option
 
diff --git a/src/data/CCSimple_queue.mli b/src/data/CCSimple_queue.mli
index 647b360a..1bbfd53e 100644
--- a/src/data/CCSimple_queue.mli
+++ b/src/data/CCSimple_queue.mli
@@ -7,10 +7,6 @@
     @since 1.3 *)
 
 
-(* TODO: remove for 3.0 *)
-type 'a sequence = ('a -> unit) -> unit
-(** @deprecated use ['a iter] instead *)
-
 type 'a iter = ('a -> unit) -> unit
 (** Fast internal iterator.
     @since 2.8 *)
diff --git a/src/data/CCTrie.ml b/src/data/CCTrie.ml
index 01cde777..ff2a955f 100644
--- a/src/data/CCTrie.ml
+++ b/src/data/CCTrie.ml
@@ -3,7 +3,7 @@
 
 (** {1 Prefix Tree} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a ktree = unit -> [`Nil | `Node of 'a * 'a ktree list]
 
 (** {2 Signatures} *)
@@ -17,7 +17,7 @@ module type WORD = sig
   type char_
 
   val compare : char_ -> char_ -> int
-  val to_seq : t -> char_ sequence
+  val to_iter : t -> char_ iter
   val of_list : char_ list -> t
 end
 
@@ -92,21 +92,21 @@ module type S = sig
 
   val of_list : (key * 'a) list -> 'a t
 
-  val to_seq : 'a t -> (key * 'a) sequence
+  val to_iter : 'a t -> (key * 'a) iter
 
-  val of_seq : (key * 'a) sequence -> 'a t
+  val of_iter : (key * 'a) iter -> 'a t
 
-  val to_seq_values : 'a t -> 'a sequence
+  val to_iter_values : 'a t -> 'a iter
 
   val to_tree : 'a t -> [`Char of char_ | `Val of 'a | `Switch] ktree
 
   (** {6 Ranges} *)
 
-  val above : key -> 'a t -> (key * 'a) sequence
+  val above : key -> 'a t -> (key * 'a) iter
   (** All bindings whose key is bigger or equal to the given key, in
       ascending order *)
 
-  val below : key -> 'a t -> (key * 'a) sequence
+  val below : key -> 'a t -> (key * 'a) iter
   (** All bindings whose key is smaller or equal to the given key,
       in decreasing order *)
 
@@ -183,27 +183,27 @@ module Make(W : WORD)
 
   (* fold [f] on [seq] with accumulator [acc], and call [finish]
      on the accumulator once [seq] is exhausted *)
-  let _fold_seq_and_then f ~finish acc seq =
+  let _fold_iter_and_then f ~finish acc seq =
     let acc = ref acc in
     seq (fun x -> acc := f !acc x);
     finish !acc
 
-  let _filter_map_seq f seq k =
+  let _filter_map_iter f seq k =
     seq (fun x -> match f x with
       | None -> ()
       | Some y -> k y)
 
-  let _seq_map f seq k = seq (fun x -> k (f x))
+  let _iter_map f seq k = seq (fun x -> k (f x))
 
-  let _seq_append_list_rev l seq =
+  let _iter_append_list_rev l seq =
     let l = ref l in
     seq (fun x -> l := x :: !l);
     !l
 
-  let _seq_append_list l seq =
-    List.rev_append (_seq_append_list_rev [] seq) l
+  let _iter_append_list l seq =
+    List.rev_append (_iter_append_list_rev [] seq) l
 
-  let seq_of_map map k =
+  let iter_of_map map k =
     M.iter (fun key v -> k (key,v)) map
 
   (* return common prefix, and disjoint suffixes *)
@@ -300,8 +300,8 @@ module Make(W : WORD)
         let value' = f value in
         rebuild (_mk_node value' map)
     in
-    let word = W.to_seq key in
-    _fold_seq_and_then goto ~finish (t, _id) word
+    let word = W.to_iter key in
+    _fold_iter_and_then goto ~finish (t, _id) word
 
   let add k v t = update k (fun _ -> Some v) t
 
@@ -328,8 +328,8 @@ module Make(W : WORD)
       | Node (Some v, _) -> v
       | _ -> raise Not_found
     in
-    let word = W.to_seq k in
-    _fold_seq_and_then goto ~finish t word
+    let word = W.to_iter k in
+    _fold_iter_and_then goto ~finish t word
 
   let find k t =
     try Some (find_exn k t)
@@ -357,8 +357,8 @@ module Make(W : WORD)
     and finish (_,prefix) =
       W.of_list (prefix [])
     in
-    let word = W.to_seq k in
-    _fold_seq_and_then goto ~finish (t,_id) word
+    let word = W.to_iter k in
+    _fold_iter_and_then goto ~finish (t,_id) word
 
   (*$= & ~printer:CCFun.id
     "ca" (String.longest_prefix "carte" s1)
@@ -517,10 +517,10 @@ module Make(W : WORD)
       (fun (l1,l2) ->
         let t1 = S.of_list l1 and t2 = S.of_list l2 in
         let t = S.merge (fun a _ -> Some a) t1 t2 in
-        S.to_seq t |> Iter.for_all
+        S.to_iter t |> Iter.for_all
           (fun (k,v) -> S.find k t1 = Some v || S.find k t2 = Some v) &&
-        S.to_seq t1 |> Iter.for_all (fun (k,v) -> S.find k t <> None) &&
-        S.to_seq t2 |> Iter.for_all (fun (k,v) -> S.find k t <> None))
+        S.to_iter t1 |> Iter.for_all (fun (k,v) -> S.find k t <> None) &&
+        S.to_iter t2 |> Iter.for_all (fun (k,v) -> S.find k t <> None))
   *)
 
   let rec size t = match t with
@@ -541,12 +541,12 @@ module Make(W : WORD)
   let of_list l =
     List.fold_left (fun acc (k,v) -> add k v acc) empty l
 
-  let to_seq t k = iter (fun key v -> k (key,v)) t
+  let to_iter t k = iter (fun key v -> k (key,v)) t
 
-  let to_seq_values t k = iter_values k t
+  let to_iter_values t k = iter_values k t
 
-  let of_seq seq =
-    _fold_seq_and_then (fun acc (k,v) -> add k v acc) ~finish:_id empty seq
+  let of_iter seq =
+    _fold_iter_and_then (fun acc (k,v) -> add k v acc) ~finish:_id empty seq
 
   let rec to_tree t () =
     let _tree_node x l () = `Node (x,l) in
@@ -583,13 +583,13 @@ module Make(W : WORD)
         | Some v, Above -> k (W.of_list (prefix[]), v)
         | _ -> ()
       end;
-      let seq = seq_of_map map in
-      let seq = _seq_map (fun (c,t') -> Explore (t', _difflist_add prefix c)) seq in
+      let seq = iter_of_map map in
+      let seq = _iter_map (fun (c,t') -> Explore (t', _difflist_add prefix c)) seq in
       let l' = match o, dir with
-        | _, Above -> _seq_append_list [] seq
-        | None, Below -> _seq_append_list_rev [] seq
+        | _, Above -> _iter_append_list [] seq
+        | None, Below -> _iter_append_list_rev [] seq
         | Some v, Below ->
-          _seq_append_list_rev [Yield (v, prefix)] seq
+          _iter_append_list_rev [Yield (v, prefix)] seq
       in
       List.iter (explore ~dir k) l'
 
@@ -598,7 +598,7 @@ module Make(W : WORD)
     with Invalid_argument _ -> false
 
   let _key_to_list key =
-    List.rev (_seq_append_list_rev [] (W.to_seq key))
+    List.rev (_iter_append_list_rev [] (W.to_iter key))
 
   (* range above (if [above = true]) or below a threshold .
      [p c c'] must return [true] if [c'], in the tree, meets some criterion
@@ -622,8 +622,8 @@ module Make(W : WORD)
             | _ -> alternatives
           in
           let alternatives =
-            let seq = seq_of_map map in
-            let seq = _filter_map_seq
+            let seq = iter_of_map map in
+            let seq = _filter_map_iter
                 (fun (c', t') ->
                    if p ~cur:c ~other:c'
                    then Some (Explore (t', _difflist_add trail c'))
@@ -634,8 +634,8 @@ module Make(W : WORD)
                - Above: explore alternatives in increasing order
                - Below: explore alternatives in decreasing order *)
             match dir with
-              | Above -> _seq_append_list alternatives seq
-              | Below -> _seq_append_list_rev alternatives seq
+              | Above -> _iter_append_list alternatives seq
+              | Below -> _iter_append_list_rev alternatives seq
           in
           begin
             try
@@ -660,8 +660,8 @@ module Make(W : WORD)
       end;
       List.iter (explore ~dir k) alternatives
     in
-    let word = W.to_seq key in
-    _fold_seq_and_then on_char ~finish (Some(t,_id), []) word
+    let word = W.to_iter key in
+    _fold_iter_and_then on_char ~finish (Some(t,_id), []) word
 
   let above key t =
     _half_range ~dir:Above ~p:(fun ~cur ~other -> W.compare cur other < 0) key t
@@ -686,7 +686,7 @@ module Make(W : WORD)
         type t = (unit -> char) list \
         type char_ = char \
         let compare = compare \
-        let to_seq a k = List.iter (fun c -> k (c ())) a \
+        let to_iter a k = List.iter (fun c -> k (c ())) a \
         let of_list l = List.map (fun c -> (fun () -> c)) l \
       end) \
     in \
@@ -743,7 +743,7 @@ module MakeArray(X : ORDERED) = Make(struct
     type t = X.t array
     type char_ = X.t
     let compare = X.compare
-    let to_seq a k = Array.iter k a
+    let to_iter a k = Array.iter k a
     let of_list = Array.of_list
   end)
 
@@ -751,7 +751,7 @@ module MakeList(X : ORDERED) = Make(struct
     type t = X.t list
     type char_ = X.t
     let compare = X.compare
-    let to_seq a k = List.iter k a
+    let to_iter a k = List.iter k a
     let of_list l = l
   end)
 
@@ -759,7 +759,7 @@ module String = Make(struct
     type t = string
     type char_ = char
     let compare = Char.compare
-    let to_seq s k = String.iter k s
+    let to_iter s k = String.iter k s
     let of_list l =
       let buf = Buffer.create (List.length l) in
       List.iter (fun c -> Buffer.add_char buf c) l;
diff --git a/src/data/CCTrie.mli b/src/data/CCTrie.mli
index c118d77f..53de1873 100644
--- a/src/data/CCTrie.mli
+++ b/src/data/CCTrie.mli
@@ -3,7 +3,7 @@
 
 (** {1 Prefix Tree} *)
 
-type 'a sequence = ('a -> unit) -> unit
+type 'a iter = ('a -> unit) -> unit
 type 'a ktree = unit -> [`Nil | `Node of 'a * 'a ktree list]
 
 (** {2 Signatures} *)
@@ -17,7 +17,7 @@ module type WORD = sig
   type char_
 
   val compare : char_ -> char_ -> int
-  val to_seq : t -> char_ sequence
+  val to_iter : t -> char_ iter
   val of_list : char_ list -> t
 end
 
@@ -92,21 +92,21 @@ module type S = sig
 
   val of_list : (key * 'a) list -> 'a t
 
-  val to_seq : 'a t -> (key * 'a) sequence
+  val to_iter : 'a t -> (key * 'a) iter
 
-  val of_seq : (key * 'a) sequence -> 'a t
+  val of_iter : (key * 'a) iter -> 'a t
 
-  val to_seq_values : 'a t -> 'a sequence
+  val to_iter_values : 'a t -> 'a iter
 
   val to_tree : 'a t -> [`Char of char_ | `Val of 'a | `Switch] ktree
 
   (** {4 Ranges} *)
 
-  val above : key -> 'a t -> (key * 'a) sequence
+  val above : key -> 'a t -> (key * 'a) iter
   (** All bindings whose key is bigger or equal to the given key, in
       ascending order. *)
 
-  val below : key -> 'a t -> (key * 'a) sequence
+  val below : key -> 'a t -> (key * 'a) iter
   (** All bindings whose key is smaller or equal to the given key,
       in decreasing order. *)