mirror of
https://github.com/c-cube/ocaml-containers.git
synced 2026-01-21 16:56:39 -05:00
break: convert sequence to iter in data
This commit is contained in:
Fardale
Fardale
parent
08d59ea07a
commit
c22fed18de
38 changed files with 261 additions and 308 deletions
|
|
@ -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
|
||||
*)
|
||||
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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 =
|
||||
|
|
|
|||
|
|
@ -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 *)
|
||||
|
|
|
|||
|
|
@ -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) )
|
||||
*)
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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} *)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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) )
|
||||
*)
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
*)
|
||||
|
||||
|
|
|
|||
|
|
@ -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. *)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 *)
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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 *)
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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. *)
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue