val append_l : 'a t list -> 'a tval concat : 'a t t -> 'a tval seq_list : 'a t list -> 'a list t
+seq_list l returns all the ways to pick one element in each sub-sequence
+ in l. Assumes the sub-sequences can be iterated on several times.
+Since 0.11
+
+
+val seq_list_map : ('a -> 'b t) -> 'a list -> 'b list t
+
val filter_map : ('a -> 'b option) -> 'a t -> 'b t
Map and only keep non-None elements
Formerly fmap
Since 0.5
+val filter_mapi : (int -> 'a -> 'b option) -> 'a t -> 'b t
+Map with indices, and only keep non-None elements
+Since 0.11
+
+
val intersperse : 'a -> 'a t -> 'a t
Insert the single element between every element of the sequence
@@ -340,20 +363,22 @@ Checks whether the sequence is sorted. Eager, same as val group_succ_by : ?eq:('a -> 'a -> bool) -> 'a t -> 'a list t
-Group equal consecutive elements.
+Group equal consecutive elements. Linear time.
Formerly synonym to group.
Since 0.6
val group_by : ?hash:('a -> int) ->
?eq:('a -> 'a -> bool) -> 'a t -> 'a list t
Group equal elements, disregarding their order of appearance.
- The result sequence is traversable as many times as required.
+ The result sequence is traversable as many times as required.
+ precondition: for any x and y, if eq x y then hash x=hash y must hold.
Since 0.6
val count : ?hash:('a -> int) ->
?eq:('a -> 'a -> bool) -> 'a t -> ('a * int) t
Map each distinct element to its number of occurrences in the whole seq.
- Similar to group_by seq |> map (fun l->List.hd l, List.length l)
+ Similar to group_by seq |> map (fun l->List.hd l, List.length l)
+ precondition: for any x and y, if eq x y then hash x=hash y must hold.
Since 0.10
@@ -399,7 +424,8 @@ Binary version of Sequence
elements resp. with key1 and key2, and combine
values (x,y) from (a,b) with the same key
using merge. If merge returns None, the combination
- of values is discarded.
+ of values is discarded.
+ precondition: for any x and y, if eq x y then hash x=hash y must hold.
Since 0.10
@@ -423,19 +449,22 @@ Binary version of Sequence
the first sequence, all the elements y of the second
sequence such that eq x (key y). Elements of the first
sequences without corresponding values in the second one
- are mapped to []
+ are mapped to []
+ precondition: for any x and y, if eq x y then hash x=hash y must hold.
Since 0.10
val inter : ?eq:'a equal ->
?hash:'a hash -> 'a t -> 'a t -> 'a t
Intersection of two collections. Each element will occur at most once
- in the result. Eager.
+ in the result. Eager.
+ precondition: for any x and y, if eq x y then hash x=hash y must hold.
Since 0.10
val union : ?eq:'a equal ->
?hash:'a hash -> 'a t -> 'a t -> 'a t
Union of two collections. Each element will occur at most once
- in the result. Eager.
+ in the result. Eager.
+ precondition: for any x and y, if eq x y then hash x=hash y must hold.
Since 0.10
@@ -445,7 +474,8 @@ Set difference. Eager.
val subset : ?eq:'a equal ->
?hash:'a hash -> 'a t -> 'a t -> bool
-subset a b returns true if all elements of a belong to b. Eager.
+subset a b returns true if all elements of a belong to b. Eager.
+ precondition: for any x and y, if eq x y then hash x=hash y must hold.
Since 0.10
@@ -482,6 +512,16 @@ Unsafe version of Sequence.min
Raises Not_found if the sequence is empty
+val sum : int t -> int
+Sum of elements
+Since 0.11
+
+
+val sumf : float t -> float
+Sum of elements, using Kahan summation
+Since 0.11
+
+
val head : 'a t -> 'a option
First element, if any, otherwise None
Since 0.5.1
@@ -560,6 +600,11 @@ Get the list of the reversed sequence (more efficient than val pair_with_idx : 'a t -> (int * 'a) t
+
val to_opt : 'a t -> 'a option
Alias to Sequence.head
Since 0.5.1
diff --git a/api/SequenceLabels.IO.html b/api/SequenceLabels.IO.html
index 8fa3a0a..2ba30bf 100644
--- a/api/SequenceLabels.IO.html
+++ b/api/SequenceLabels.IO.html
@@ -49,10 +49,14 @@ Read chunks of the given size from the file. The last
flags : used by open_out_gen. Default: [Open_creat;Open_wronly].
val write_bytes_to : ?mode:int ->
?flags:Pervasives.open_flag list ->
string -> Bytes.t SequenceLabels.t -> unit
+Since 0.5.4
val write_lines : ?mode:int ->
?flags:Pervasives.open_flag list -> string -> string SequenceLabels.t -> unit
-val write_bytes_lines : ?mode:int ->
?flags:Pervasives.open_flag list ->
string -> Bytes.t SequenceLabels.t -> unit