simon/ocaml-containers
1
0
Fork 0
mirror of https://github.com/c-cube/ocaml-containers.git synced 2025-12-05 19:00:31 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

chore: use iter, not sequence, in tests

Browse source
This commit is contained in:
Simon Cruanes 2019-04-13 03:12:22 -05:00
parent 0d6c922eb1
commit 3712db3a5b
29 changed files with 132 additions and 132 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
benchs/dune
View file

@ -2,7 +2,7 @@
(executables
(names run_benchs run_bench_hash)
(libraries containers containers.data containers.iter
containers.thread benchmark gen sequence qcheck
containers.thread benchmark gen iter qcheck
batteries clarity)
(flags :standard -w +a-4-42-44-48-50-58-32-60@8 -safe-string -color always)
(ocamlopt_flags :standard -O3 -color always

2
containers.opam
View file

@ -16,7 +16,7 @@ depends: [
"qtest" { with-test }
"qcheck" { with-test }
"ounit" { with-test }
"sequence" { with-test }
"iter" { with-test }
"gen" { with-test }
"uutf" { with-test }
"mdx" { with-test }

2
qtest/dune
View file

@ -18,7 +18,7 @@
(modules run_qtest)
; disable some warnings in qtests
(flags :standard -warn-error -a -w -33-35-27-39 -nolabels)
(libraries sequence gen qcheck containers containers.unix
(libraries iter gen qcheck containers containers.unix
containers.data containers.thread containers.iter
containers.sexp uutf)
)

2
src/core/CCArray.mli
View file

@ -245,7 +245,7 @@ val shuffle_with : Random.State.t -> 'a t -> unit
val random_choose : 'a t -> 'a random_gen
(** [random_choose a rs] randomly chooses an element of [a].
@raise Invalid_argument if the array/slice is empty. *)
@raise Not_found if the array/slice is empty. *)
val to_seq : 'a t -> 'a sequence
(** [to_seq a] returns a [sequence] of the elements of an array [a].

10
src/core/CCHeap.ml
View file

@ -58,7 +58,7 @@ end
(*$QR & ~count:30
Q.(list_of_size Gen.(return 1_000) int) (fun l ->
(* put elements into a heap *)
let h = H.of_seq (Sequence.of_list l) in
let h = H.of_seq (Iter.of_list l) in
OUnit.assert_equal 1_000 (H.size h);
let l' = extract_list h in
is_sorted l'
@ -69,10 +69,10 @@ end
(*$QR & ~count:30
Q.(list_of_size Gen.(return 1_000) int) (fun l ->
(* put elements into a heap *)
let h = H.of_seq (Sequence.of_list l) in
let h = H.of_seq (Iter.of_list l) in
let h = H.filter (fun x->x mod 2=0) h in
OUnit.assert_bool "all odd"
(H.to_seq h |> Sequence.for_all (fun x -> x mod 2 = 0));
(H.to_seq h |> Iter.for_all (fun x -> x mod 2 = 0));
let l' = extract_list h in
is_sorted l'
)
@ -81,8 +81,8 @@ end
(*$QR
Q.(list_of_size Gen.(return 1_000) int) (fun l ->
(* put elements into a heap *)
let h = H.of_seq (Sequence.of_list l) in
let l' = H.to_seq_sorted h |> Sequence.to_list in
let h = H.of_seq (Iter.of_list l) in
let l' = H.to_seq_sorted h |> Iter.to_list in
is_sorted l'
)
*)

38
src/core/CCInt.ml
View file

@ -27,9 +27,9 @@ let range i j yield =
if i<=j then up i j yield else down i j yield
(*$= & ~printer:Q.Print.(list int)
[0;1;2;3;4;5] (range 0 5 |> Sequence.to_list)
[0] (range 0 0 |> Sequence.to_list)
[5;4;3;2] (range 5 2 |> Sequence.to_list)
[0;1;2;3;4;5] (range 0 5 |> Iter.to_list)
[0] (range 0 0 |> Iter.to_list)
[5;4;3;2] (range 5 2 |> Iter.to_list)
*)
let range' i j yield =
@ -38,9 +38,9 @@ let range' i j yield =
else range i (j+1) yield
(*$= & ~printer:Q.Print.(list int)
[] (range' 0 0 |> Sequence.to_list)
[0;1;2;3;4] (range' 0 5 |> Sequence.to_list)
[5;4;3] (range' 5 2 |> Sequence.to_list)
[] (range' 0 0 |> Iter.to_list)
[0;1;2;3;4] (range' 0 5 |> Iter.to_list)
[5;4;3] (range' 5 2 |> Iter.to_list)
*)
let sign i =
@ -258,23 +258,23 @@ let range_by ~step i j yield =
(* note: the last test checks that no error occurs due to overflows. *)
(*$= & ~printer:Q.Print.(list int)
[0] (range_by ~step:1 0 0 |> Sequence.to_list)
[] (range_by ~step:1 5 0 |> Sequence.to_list)
[] (range_by ~step:2 1 0 |> Sequence.to_list)
[0;2;4] (range_by ~step:2 0 4 |> Sequence.to_list)
[0;2;4] (range_by ~step:2 0 5 |> Sequence.to_list)
[0] (range_by ~step:~-1 0 0 |> Sequence.to_list)
[] (range_by ~step:~-1 0 5 |> Sequence.to_list)
[] (range_by ~step:~-2 0 1 |> Sequence.to_list)
[5;3;1] (range_by ~step:~-2 5 1 |> Sequence.to_list)
[5;3;1] (range_by ~step:~-2 5 0 |> Sequence.to_list)
[0] (range_by ~step:max_int 0 2 |> Sequence.to_list)
[0] (range_by ~step:1 0 0 |> Iter.to_list)
[] (range_by ~step:1 5 0 |> Iter.to_list)
[] (range_by ~step:2 1 0 |> Iter.to_list)
[0;2;4] (range_by ~step:2 0 4 |> Iter.to_list)
[0;2;4] (range_by ~step:2 0 5 |> Iter.to_list)
[0] (range_by ~step:~-1 0 0 |> Iter.to_list)
[] (range_by ~step:~-1 0 5 |> Iter.to_list)
[] (range_by ~step:~-2 0 1 |> Iter.to_list)
[5;3;1] (range_by ~step:~-2 5 1 |> Iter.to_list)
[5;3;1] (range_by ~step:~-2 5 0 |> Iter.to_list)
[0] (range_by ~step:max_int 0 2 |> Iter.to_list)
*)
(*$Q
Q.(pair small_int small_int) (fun (i,j) -> \
let i = min i j and j = max i j in \
CCList.equal CCInt.equal \
(CCInt.range_by ~step:1 i j |> Sequence.to_list) \
(CCInt.range i j |> Sequence.to_list) )
(CCInt.range_by ~step:1 i j |> Iter.to_list) \
(CCInt.range i j |> Iter.to_list) )
*)

2
src/core/CCInt.mli
View file

@ -82,7 +82,7 @@ val range : t -> t -> t sequence
val range' : t -> t -> t sequence
(** Like {!range} but the second bound is excluded.
For instance [range' 0 5 = Sequence.of_list [0;1;2;3;4]].
For instance [range' 0 5 = Iter.of_list [0;1;2;3;4]].
@since 1.2 *)
(** {2 Infix Operators}

6
src/core/CCOpt.ml
View file

@ -189,9 +189,9 @@ let choice_seq s =
!r
(*$T
choice_seq (Sequence.of_list [None; Some 1; Some 2]) = Some 1
choice_seq Sequence.empty = None
choice_seq (Sequence.repeat None |> Sequence.take 100) = None
choice_seq (Iter.of_list [None; Some 1; Some 2]) = Some 1
choice_seq Iter.empty = None
choice_seq (Iter.repeat None |> Iter.take 100) = None
*)
let to_gen o =

4
src/core/CCString.ml
View file

@ -1135,14 +1135,14 @@ module Sub = struct
(*$QR
Q.(printable_string_of_size Gen.(3--10)) (fun s ->
let open Sequence.Infix in
let open Iter.Infix in
begin
(0 -- (length s-2)
>|= fun i -> i, Sub.make s i ~len:(length s-i))
>>= fun (i,sub) ->
(0 -- (Sub.length sub-1) >|= fun j -> i,j,sub)
end
|> Sequence.for_all
|> Iter.for_all
(fun (i,j,sub) -> Sub.get sub j = s.[i+j]))
*)

4
src/core/CCUtf8_string.ml
View file

@ -325,8 +325,8 @@ let of_string s = if is_valid s then Some s else None
Q.small_string (fun s ->
Q.assume (is_valid s && uutf_is_valid s);
let pp s = Q.Print.(list pp_uchar) s in
let l_uutf = uutf_to_seq s |> Sequence.to_list in
let l_co = of_string_exn s |> to_seq |> Sequence.to_list in
let l_uutf = uutf_to_seq s |> Iter.to_list in
let l_co = of_string_exn s |> to_seq |> Iter.to_list in
if l_uutf = l_co then true
else Q.Test.fail_reportf "uutf: '%s', containers: '%s', is_valid %B, uutf_is_valid %B"
(pp l_uutf) (pp l_co) (is_valid s) (uutf_is_valid s)

2
src/core/CCUtf8_string.mli
View file

@ -42,7 +42,7 @@ val to_gen : ?idx:int -> t -> uchar gen
@param idx offset where to start the decoding. *)
val to_seq : ?idx:int -> t -> uchar sequence
(** Sequence of unicode codepoints.
(** Iter of unicode codepoints.
@param idx offset where to start the decoding. *)
val to_list : ?idx:int -> t -> uchar list

30
src/core/CCVector.ml
View file

@ -125,11 +125,11 @@ let clear v =
v.size <- 0
(*$R
let v = of_seq Sequence.(1 -- 10) in
let v = of_seq Iter.(1 -- 10) in
OUnit.assert_equal 10 (size v);
clear v;
OUnit.assert_equal 0 (size v);
OUnit.assert_bool "empty_after_clear" (Sequence.is_empty (to_seq v));
OUnit.assert_bool "empty_after_clear" (Iter.is_empty (to_seq v));
*)
let is_empty v = v.size = 0
@ -176,12 +176,12 @@ let append a b =
*)
(*$R
let a = of_seq Sequence.(1 -- 5) in
let b = of_seq Sequence.(6 -- 10) in
let a = of_seq Iter.(1 -- 5) in
let b = of_seq Iter.(6 -- 10) in
append a b;
OUnit.assert_equal 10 (size a);
OUnit.assert_equal (Sequence.to_array Sequence.(1 -- 10)) (to_array a);
OUnit.assert_equal (Sequence.to_array Sequence.(6 -- 10)) (to_array b);
OUnit.assert_equal (Iter.to_array Iter.(1 -- 10)) (to_array a);
OUnit.assert_equal (Iter.to_array Iter.(6 -- 10)) (to_array b);
*)
let get v i =
@ -269,8 +269,8 @@ let rec append_gen a b = match b() with
(Q.pair (gen Q.int) (gen Q.int)) (fun (v1,v2) ->
let l1 = to_list v1 in
append v1 v2;
Sequence.to_list (to_seq v1) =
Sequence.(to_list (append (of_list l1) (to_seq v2)))
Iter.to_list (to_seq v1) =
Iter.(to_list (append (of_list l1) (to_seq v2)))
)
*)
@ -359,7 +359,7 @@ let copy v = {
*)
(*$R
let v = of_seq Sequence.(1 -- 100) in
let v = of_seq Iter.(1 -- 100) in
OUnit.assert_equal 100 (size v);
let v' = copy v in
OUnit.assert_equal 100 (size v');
@ -386,7 +386,7 @@ let shrink v n =
)
(*$R
let v = of_seq Sequence.(1 -- 10) in
let v = of_seq Iter.(1 -- 10) in
shrink v 5;
OUnit.assert_equal [1;2;3;4;5] (to_list v);
*)
@ -395,7 +395,7 @@ let shrink v n =
(gen Q.small_int) (fun v ->
let n = size v / 2 in
let l = to_list v in
let h = Sequence.(to_list (take n (of_list l))) in
let h = Iter.(to_list (take n (of_list l))) in
let v' = copy v in
shrink v' n;
h = to_list v'
@ -782,13 +782,13 @@ let rev_iter f v =
done
(*$T
let v = of_list [1;2;3] in (fun f->rev_iter f v) |> Sequence.to_list = [3;2;1]
let v = of_list [1;2;3] in (fun f->rev_iter f v) |> Iter.to_list = [3;2;1]
*)
(*$Q
Q.(list int) (fun l -> \
let v = of_list l in \
(fun f->rev_iter f v) |> Sequence.to_list = List.rev l)
(fun f->rev_iter f v) |> Iter.to_list = List.rev l)
*)
let size v = v.size
@ -804,7 +804,7 @@ let of_seq ?(init=create ()) seq =
init
(*$T
of_seq Sequence.(1 -- 10) |> to_list = CCList.(1 -- 10)
of_seq Iter.(1 -- 10) |> to_list = CCList.(1 -- 10)
*)
let to_seq v k = iter k v
@ -817,7 +817,7 @@ let to_seq_rev v k =
(*$Q
Q.(list int) (fun l -> \
let v= of_list l in v |> to_seq_rev |> Sequence.to_rev_list = l)
let v= of_list l in v |> to_seq_rev |> Iter.to_rev_list = l)
*)
let slice_seq v start len =

12
src/data/CCBV.ml
View file

@ -262,16 +262,16 @@ let iter bv f =
*)
(*$= & ~printer:Q.Print.(list (pair int bool))
[] (iter (create ~size:0 false) |> seq_zip |> Sequence.to_list)
[] (iter (create ~size:0 false) |> seq_zip |> Iter.to_list)
[0, false; 1, true; 2, false] \
(iter (let bv = create ~size:3 false in set bv 1; bv) |> seq_zip |> Sequence.to_list)
(iter (let bv = create ~size:3 false in set bv 1; bv) |> seq_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 |> Sequence.to_list in \
let l = iter bv |> seq_zip |> Iter.to_list in \
List.length l = n && List.for_all (fun (_,b) -> b) l)
*)
@ -279,7 +279,7 @@ let iter_true bv f =
iter bv (fun i b -> if b then f i else ())
(*$T
of_list [1;5;7] |> iter_true |> Sequence.to_list |> List.sort CCOrd.compare = [1;5;7]
of_list [1;5;7] |> iter_true |> Iter.to_list |> List.sort CCOrd.compare = [1;5;7]
*)
(*$inject
@ -292,7 +292,7 @@ let iter_true bv f =
(*$QR
gen_bv (fun bv ->
let l' = Sequence.to_rev_list (CCBV.iter_true bv) in
let l' = Iter.to_rev_list (CCBV.iter_true bv) in
let bv' = CCBV.of_list l' in
CCBV.cardinal bv = CCBV.cardinal bv'
)
@ -538,7 +538,7 @@ let to_seq bv k = iter_true bv k
Q.(small_int) (fun i -> \
let i = max 1 i in \
let bv = create ~size:i true in \
i = (to_seq bv |> Sequence.length))
i = (to_seq bv |> Iter.length))
*)
let of_seq seq =

24
src/data/CCDeque.ml
View file

@ -33,9 +33,9 @@ type 'a t = {
(*$R
let q = create () in
add_seq_back q Sequence.(3 -- 5);
add_seq_back q Iter.(3 -- 5);
assert_equal [3;4;5] (to_list q);
add_seq_front q Sequence.(of_list [2;1]);
add_seq_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);
@ -57,7 +57,7 @@ let clear q =
()
(*$R
let q = of_seq Sequence.(1 -- 100) in
let q = of_seq Iter.(1 -- 100) in
assert_equal 100 (length q);
clear q;
assert_equal 0 (length q);
@ -117,7 +117,7 @@ let peek_front d = match d.cur.cell with
*)
(*$R
let d = of_seq Sequence.(1 -- 10) in
let d = of_seq Iter.(1 -- 10) in
let printer = pint in
OUnit.assert_equal ~printer 1 (peek_front d);
push_front d 42;
@ -143,7 +143,7 @@ let peek_back d =
*)
(*$R
let d = of_seq Sequence.(1 -- 10) in
let d = of_seq Iter.(1 -- 10) in
let printer = pint in
OUnit.assert_equal ~printer 1 (peek_front d);
push_back d 42;
@ -229,9 +229,9 @@ let iter f d =
*)
(*$R
let d = of_seq Sequence.(1 -- 5) in
let s = Sequence.from_iter (fun k -> iter k d) in
let l = Sequence.to_list s in
let d = of_seq 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;
*)
@ -275,7 +275,7 @@ let length d = d.size
*)
(*$R
let d = of_seq Sequence.(1 -- 10) in
let d = of_seq Iter.(1 -- 10) in
OUnit.assert_equal ~printer:pint 10 (length d)
*)
@ -288,9 +288,9 @@ let add_seq_front q seq = seq (fun x -> push_front q x)
(*$R
let q = of_list [4;5] in
add_seq_front q Sequence.(of_list [3;2;1]);
add_seq_front q Iter.(of_list [3;2;1]);
assert_equal [1;2;3;4;5] (to_list q);
add_seq_back q Sequence.(of_list [6;7]);
add_seq_back q Iter.(of_list [6;7]);
assert_equal [1;2;3;4;5;6;7] (to_list q);
*)
@ -303,7 +303,7 @@ let to_seq d k = iter k d
(*$Q
Q.(list int) (fun l -> \
Sequence.of_list l |> of_seq |> to_seq |> Sequence.to_list = l)
Iter.of_list l |> of_seq |> to_seq |> Iter.to_list = l)
*)
let of_list l =

16
src/data/CCFQueue.ml
View file

@ -95,7 +95,7 @@ let rec snoc : type a. a t -> a -> a t
let q = List.fold_left snoc empty [1;2;3;4;5] in
let q = tail q in
let q = List.fold_left snoc q [6;7;8] in
let l = Sequence.to_list (to_seq q) in
let l = Iter.to_list (to_seq q) in
OUnit.assert_equal ~printer:pp_ilist [2;3;4;5;6;7;8] l
*)
@ -321,7 +321,7 @@ let add_seq_front seq q =
(*$Q
Q.(pair (list int) (list int)) (fun (l1, l2) -> \
add_seq_front (Sequence.of_list l1) (of_list l2) |> to_list = l1 @ l2)
add_seq_front (Iter.of_list l1) (of_list l2) |> to_list = l1 @ l2)
*)
let add_seq_back q seq =
@ -345,7 +345,7 @@ let rec to_seq : 'a. 'a t -> 'a sequence
(*$Q
(Q.list Q.int) (fun l -> \
of_list l |> to_seq |> Sequence.to_list = l)
of_list l |> to_seq |> Iter.to_list = l)
*)
let append q1 q2 =
@ -360,10 +360,10 @@ let append q1 q2 =
*)
(*$R
let q1 = of_seq (Sequence.of_list [1;2;3;4]) in
let q2 = of_seq (Sequence.of_list [5;6;7;8]) in
let q1 = of_seq (Iter.of_list [1;2;3;4]) in
let q2 = of_seq (Iter.of_list [5;6;7;8]) in
let q = append q1 q2 in
let l = Sequence.to_list (to_seq q) in
let l = Iter.to_list (to_seq q) in
OUnit.assert_equal ~printer:pp_ilist [1;2;3;4;5;6;7;8] l
*)
@ -407,7 +407,7 @@ let rec fold : 'a 'b. ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
*)
(*$R
let q = of_seq (Sequence.of_list [1;2;3;4]) in
let q = of_seq (Iter.of_list [1;2;3;4]) in
let n = fold (+) 0 q in
OUnit.assert_equal 10 n;
*)
@ -425,7 +425,7 @@ let of_seq seq = add_seq_front seq empty
(*$Q
(Q.list Q.int) (fun l -> \
Sequence.of_list l |> of_seq |> to_list = l)
Iter.of_list l |> of_seq |> to_list = l)
*)
let rev q =

2
src/data/CCFun_vec.ml
View file

@ -325,7 +325,7 @@ let to_seq m yield = iteri ~f:(fun _ v -> yield v) m
(*$Q
_listuniq (fun l -> \
(List.sort Pervasives.compare l) = \
(l |> Sequence.of_list |> of_seq |> to_seq |> Sequence.to_list \
(l |> Iter.of_list |> of_seq |> to_seq |> Iter.to_list \
|> List.sort Pervasives.compare) )
*)

14
src/data/CCGraph.ml
View file

@ -3,13 +3,13 @@
(** {1 Simple Graph Interface} *)
(** {2 Sequence Helpers} *)
(** {2 Iter Helpers} *)
type 'a sequence = ('a -> unit) -> unit
type 'a sequence_once = 'a sequence
exception Sequence_once
exception Iter_once
let (|>) x f = f x
@ -147,7 +147,7 @@ module Traverse = struct
let first = ref true in
fun k ->
(* ensure linearity *)
if !first then first := false else raise Sequence_once;
if !first then first := false else raise Iter_once;
Seq.iter bag.push seq;
while not (bag.is_empty ()) do
let x = bag.pop () in
@ -243,7 +243,7 @@ module Traverse = struct
let dfs_tag ~eq ~tags ~graph seq =
let first = ref true in
fun k ->
if !first then first := false else raise Sequence_once;
if !first then first := false else raise Iter_once;
let bag = mk_stack() in
let n = ref 0 in
Seq.iter
@ -290,8 +290,8 @@ module Traverse = struct
(*$R
let l =
let tbl = mk_table ~eq:CCInt.equal 128 in
Traverse.Event.dfs ~tbl ~eq:CCInt.equal ~graph:divisors_graph (Sequence.return 345614)
|> Sequence.to_list in
Traverse.Event.dfs ~tbl ~eq:CCInt.equal ~graph:divisors_graph (Iter.return 345614)
|> Iter.to_list in
let expected =
[`Enter (345614, 0, []); `Edge (345614, (), 172807, `Forward);
`Enter (172807, 1, [(345614, (), 172807)]); `Edge (172807, (), 1, `Forward);
@ -433,7 +433,7 @@ module SCC = struct
let explore ~tbl ~graph seq =
let first = ref true in
fun k ->
if !first then first := false else raise Sequence_once;
if !first then first := false else raise Iter_once;
(* stack of nodes being explored, for the DFS *)
let to_explore = Stack.create() in
(* stack for Tarjan's algorithm itself *)

8
src/data/CCGraph.mli
View file

@ -23,15 +23,15 @@
@since 0.12 *)
(** {2 Sequence Helpers} *)
(** {2 Iter Helpers} *)
type 'a sequence = ('a -> unit) -> unit
(** A sequence of items of type ['a], possibly infinite *)
type 'a sequence_once = 'a sequence
(** Sequence that should be used only once *)
(** Iter that should be used only once *)
exception Sequence_once
exception Iter_once
(** Raised when a sequence meant to be used once is used several times. *)
module Seq : sig
@ -274,7 +274,7 @@ val scc : tbl:('v, 'v scc_state) table ->
components, and C1 points to C2, then C2 will be yielded before C1).
Uses {{: https://en.wikipedia.org/wiki/Tarjan's_strongly_connected_components_algorithm} Tarjan's algorithm}.
@param tbl table used to map nodes to some hidden state.
@raise Sequence_once if the result is iterated on more than once.
@raise Iter_once if the result is iterated on more than once.
*)
(** {2 Pretty printing in the DOT (graphviz) format}

10
src/data/CCHashTrie.ml
View file

@ -673,7 +673,7 @@ module Make(Key : KEY)
(*$Q
_listuniq (fun l -> \
(List.sort Pervasives.compare l) = \
(l |> Sequence.of_list |> M.of_seq |> M.to_seq |> Sequence.to_list \
(l |> Iter.of_list |> M.of_seq |> M.to_seq |> Iter.to_list \
|> List.sort Pervasives.compare) )
*)
@ -759,12 +759,12 @@ end
let m = M.of_list CCList.( (501 -- 1000) @ (500 -- 1) |> map (fun i->i,i)) in
assert_equal ~printer:CCInt.to_string 1000 (M.cardinal m);
assert_bool "check all get"
(Sequence.for_all (fun i -> i = M.get_exn i m) Sequence.(1 -- 1000));
let m = Sequence.(501 -- 1000 |> fold (fun m i -> M.remove i m) m) in
(Iter.for_all (fun i -> i = M.get_exn i m) Iter.(1 -- 1000));
let m = Iter.(501 -- 1000 |> fold (fun m i -> M.remove i m) m) in
assert_equal ~printer:CCInt.to_string 500 (M.cardinal m);
assert_bool "check all get after remove"
(Sequence.for_all (fun i -> i = M.get_exn i m) Sequence.(1 -- 500));
(Iter.for_all (fun i -> i = M.get_exn i m) Iter.(1 -- 500));
assert_bool "check all get after remove"
(Sequence.for_all (fun i -> None = M.get i m) Sequence.(501 -- 1000));
(Iter.for_all (fun i -> None = M.get i m) Iter.(501 -- 1000));
*)

4
src/data/CCImmutArray.ml
View file

@ -87,8 +87,8 @@ let of_seq s =
(*$Q
Q.(list int) (fun l -> \
let g = Sequence.of_list l in \
of_seq g |> to_seq |> Sequence.to_list = l)
let g = Iter.of_list l in \
of_seq g |> to_seq |> Iter.to_list = l)
*)
let rec gen_to_list_ acc g = match g() with

6
src/data/CCMixtbl.ml
View file

@ -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 |> Sequence.to_list in
let l = keys_seq tbl |> Iter.to_list in
OUnit.assert_equal ["baaz"; "bar"; "foo"] (List.sort compare l);
*)
@ -163,8 +163,8 @@ let bindings tbl yield =
set ~inj:inj_int tbl "bar" 2;
set ~inj:inj_str tbl "baaz" "hello";
set ~inj:inj_str tbl "str" "rts";
let l_int = bindings_of ~inj:inj_int tbl |> Sequence.to_list in
let l_int = bindings_of ~inj:inj_int tbl |> Iter.to_list in
OUnit.assert_equal ["bar", 2; "foo", 1] (List.sort compare l_int);
let l_str = bindings_of ~inj:inj_str tbl |> Sequence.to_list in
let l_str = bindings_of ~inj:inj_str tbl |> Iter.to_list in
OUnit.assert_equal ["baaz", "hello"; "str", "rts"] (List.sort compare l_str);
*)

18
src/data/CCPersistentHashtbl.ml
View file

@ -102,7 +102,7 @@ module type S = sig
val add_list : 'a t -> (key * 'a) list -> 'a t
val to_seq : 'a t -> (key * 'a) sequence
(** Sequence of the bindings of the table *)
(** 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 = Sequence.of_list my_list
let my_seq = Iter.of_list my_list
let _list_uniq = CCList.sort_uniq
~cmp:(fun a b -> Pervasives.compare (fst a) (fst b))
@ -234,9 +234,9 @@ module Make(H : HashedType) : S with type key = H.t = struct
(*$R
let n = 10000 in
let seq = Sequence.map (fun i -> i, string_of_int i) Sequence.(0--n) in
let seq = Iter.map (fun i -> i, string_of_int i) Iter.(0--n) in
let h = H.of_seq seq in
Sequence.iter
Iter.iter
(fun (k,v) ->
OUnit.assert_equal ~printer:(fun x -> x) v (H.find h k))
seq;
@ -268,7 +268,7 @@ module Make(H : HashedType) : S with type key = H.t = struct
(*$R
let h = H.of_seq
Sequence.(map (fun i -> i, string_of_int i)
Iter.(map (fun i -> i, string_of_int i)
(0 -- 200)) in
OUnit.assert_equal 201 (H.length h);
*)
@ -425,12 +425,12 @@ module Make(H : HashedType) : S with type key = H.t = struct
*)
(*$R
let open Sequence.Infix in
let open Iter.Infix in
let n = 10000 in
let seq = Sequence.map (fun i -> i, string_of_int i) (0 -- n) in
let seq = Iter.map (fun i -> i, string_of_int i) (0 -- n) in
let h = H.of_seq seq in
OUnit.assert_equal (n+1) (H.length h);
let h = Sequence.fold (fun h i -> H.remove h i) h (0 -- 500) in
let h = Iter.fold (fun h i -> H.remove h i) h (0 -- 500) in
OUnit.assert_equal (n-500) (H.length h);
OUnit.assert_bool "is_empty" (H.is_empty (H.create 16));
*)
@ -609,7 +609,7 @@ module Make(H : HashedType) : S with type key = H.t = struct
(*$R
let h = H.of_seq my_seq in
let l = Sequence.to_list (H.to_seq h) in
let l = Iter.to_list (H.to_seq h) in
OUnit.assert_equal my_list (List.sort compare l)
*)

2
src/data/CCPersistentHashtbl.mli
View file

@ -109,7 +109,7 @@ module type S = sig
val add_list : 'a t -> (key * 'a) list -> 'a t
val to_seq : 'a t -> (key * 'a) sequence
(** Sequence of the bindings of the table. *)
(** Iter of the bindings of the table. *)
val to_list : 'a t -> (key * 'a) list

6
src/data/CCRAL.ml
View file

@ -539,13 +539,13 @@ let to_seq l yield = iter ~f:yield l
(*$Q & ~small:List.length
Q.(list small_int) (fun l -> \
of_list l |> to_seq |> Sequence.to_list = l)
of_list l |> to_seq |> Iter.to_list = l)
Q.(list small_int) (fun l -> \
Sequence.of_list l |> of_seq |> to_list = l)
Iter.of_list l |> of_seq |> to_list = l)
*)
(*$T
add_seq (of_list [3;4]) (Sequence.of_list [1;2]) |> to_list = [1;2;3;4]
add_seq (of_list [3;4]) (Iter.of_list [1;2]) |> to_list = [1;2;3;4]
*)
let rec gen_iter_ f g = match g() with

4
src/data/CCSimple_queue.ml
View file

@ -119,10 +119,10 @@ let of_seq s = add_seq empty s
(*$Q
Q.(list small_int) (fun l -> \
equal CCInt.equal \
(of_seq (Sequence.of_list l)) \
(of_seq (Iter.of_list l)) \
(of_list l))
Q.(list small_int) (fun l -> \
l = (of_list l |> to_seq |> Sequence.to_list))
l = (of_list l |> to_seq |> Iter.to_list))
*)
let rec klist_iter_ k f = match k() with

24
src/data/CCTrie.ml
View file

@ -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 |> Sequence.for_all
S.to_seq t |> Iter.for_all
(fun (k,v) -> S.find k t1 = Some v || S.find k t2 = Some v) &&
S.to_seq t1 |> Sequence.for_all (fun (k,v) -> S.find k t <> None) &&
S.to_seq t2 |> Sequence.for_all (fun (k,v) -> S.find k t <> None))
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))
*)
let rec size t = match t with
@ -671,13 +671,13 @@ module Make(W : WORD)
(*$= & ~printer:CCFormat.(to_string (list (pair (list int) string)))
[ [1], "1"; [1;2], "12"; [1;2;3], "123"; [2;1], "21" ] \
(T.above [1] t1 |> Sequence.to_list)
(T.above [1] t1 |> Iter.to_list)
[ [1;2], "12"; [1;2;3], "123"; [2;1], "21" ] \
(T.above [1;1] t1 |> Sequence.to_list)
(T.above [1;1] t1 |> Iter.to_list)
[ [1;2], "12"; [1], "1"; [], "[]" ] \
(T.below [1;2] t1 |> Sequence.to_list)
(T.below [1;2] t1 |> Iter.to_list)
[ [1], "1"; [], "[]" ] \
(T.below [1;1] t1 |> Sequence.to_list)
(T.below [1;1] t1 |> Iter.to_list)
*)
(* NOTE: Regression test. See #158 *)
@ -691,7 +691,7 @@ module Make(W : WORD)
end) \
in \
let trie = TPoly.of_list [[fun () -> 'a'], 1; [fun () -> 'b'], 2] in \
ignore (TPoly.below [fun () -> 'a'] trie |> Sequence.to_list); \
ignore (TPoly.below [fun () -> 'a'] trie |> Iter.to_list); \
true
*)
@ -714,22 +714,22 @@ module Make(W : WORD)
Q.(list_of_size Gen.(1 -- 20) (pair gen_str small_int)) \
(fun l -> let t = String.of_list l in \
List.for_all (fun (k,_) -> \
String.above k t |> Sequence.for_all (fun (k',v) -> k' >= k)) \
String.above k t |> Iter.for_all (fun (k',v) -> k' >= k)) \
l)
Q.(list_of_size Gen.(1 -- 20) (pair gen_str small_int)) \
(fun l -> let t = String.of_list l in \
List.for_all (fun (k,_) -> \
String.below k t |> Sequence.for_all (fun (k',v) -> k' <= k)) \
String.below k t |> Iter.for_all (fun (k',v) -> k' <= k)) \
l)
Q.(list_of_size Gen.(1 -- 20) (pair gen_str small_int)) \
(fun l -> let t = String.of_list l in \
List.for_all (fun (k,_) -> \
String.above k t |> Sequence.to_list |> sorted ~rev:false) \
String.above k t |> Iter.to_list |> sorted ~rev:false) \
l)
Q.(list_of_size Gen.(1 -- 20) (pair gen_str small_int)) \
(fun l -> let t = String.of_list l in \
List.for_all (fun (k,_) -> \
String.below k t |> Sequence.to_list |> sorted ~rev:true) \
String.below k t |> Iter.to_list |> sorted ~rev:true) \
l)
*)
end

4
src/data/CCWBTree.ml
View file

@ -500,8 +500,8 @@ module MakeFull(K : KEY) : S with type key = K.t = struct
List.for_all (fun (k,v) ->
let l, v', r = M.split k m in
v' = Some v
&& (M.to_seq l |> Sequence.for_all (fun (k',_) -> k' < k))
&& (M.to_seq r |> Sequence.for_all (fun (k',_) -> k' > k))
&& (M.to_seq l |> Iter.for_all (fun (k',_) -> k' < k))
&& (M.to_seq r |> Iter.for_all (fun (k',_) -> k' > k))
&& M.balanced m
&& M.cardinal l + M.cardinal r + 1 = List.length lst
) lst)

4
src/threads/CCPool.ml
View file

@ -267,7 +267,7 @@ module Make(P : PARAM) = struct
(*$R
List.iter
(fun n ->
let l = Sequence.(1 -- n) |> Sequence.to_list in
let l = Iter.(1 -- n) |> Iter.to_list in
let l = List.rev_map (fun i ->
Fut.make
(fun () ->
@ -283,7 +283,7 @@ module Make(P : PARAM) = struct
(*$R
List.iter
(fun n ->
let l = Sequence.(1 -- n) |> Sequence.to_list in
let l = Iter.(1 -- n) |> Iter.to_list in
let l = List.rev_map (fun i ->
Fut2.make
(fun () ->

2
src/threads/CCThread.ml
View file

@ -32,7 +32,7 @@ end
let l = CCLock.create 0 in
let a = Arr.spawn 101 (fun i -> CCLock.update l ((+) i)) in
Arr.join a;
let n = Sequence.(1 -- 100 |> fold (+) 0) in
let n = Iter.(1 -- 100 |> fold (+) 0) in
assert_equal ~printer:CCInt.to_string n (CCLock.get l)
*)