From e69b4ca0c5cbd189ebc958c6403e4675a2547cd3 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Fri, 15 Dec 2017 13:39:08 +0100 Subject: [PATCH] update api --- api/Sequence.html | 61 +++++++++-- api/SequenceLabels.IO.html | 6 +- api/SequenceLabels.Infix.html | 4 + api/SequenceLabels.html | 142 ++++++++++++++++++++++++- api/html.stamp | 2 +- api/index_types.html | 4 + api/index_values.html | 139 +++++++++++++++++++++++- api/style.css | 2 +- api/type_Sequence.Map.Adapt.html | 8 ++ api/type_Sequence.Map.Make.html | 8 ++ api/type_Sequence.Map.S.html | 8 ++ api/type_Sequence.Map.html | 24 +++++ api/type_Sequence.Set.Adapt.html | 8 ++ api/type_Sequence.Set.Make.html | 8 ++ api/type_Sequence.Set.S.html | 8 ++ api/type_Sequence.Set.html | 24 +++++ api/type_Sequence.html | 56 ++++++++++ api/type_SequenceLabels.Map.Adapt.html | 8 ++ api/type_SequenceLabels.Map.Make.html | 8 ++ api/type_SequenceLabels.Map.S.html | 8 ++ api/type_SequenceLabels.Map.html | 24 +++++ api/type_SequenceLabels.Set.Adapt.html | 8 ++ api/type_SequenceLabels.Set.Make.html | 8 ++ api/type_SequenceLabels.Set.S.html | 8 ++ api/type_SequenceLabels.Set.html | 24 +++++ api/type_SequenceLabels.html | 102 +++++++++++++++++- 26 files changed, 695 insertions(+), 15 deletions(-) diff --git a/api/Sequence.html b/api/Sequence.html index 8a81dad..e5e566f 100644 --- a/api/Sequence.html +++ b/api/Sequence.html @@ -270,6 +270,12 @@ Append two sequences. Iterating on the result is like iterating on the first, then on the second.
+
val append_l : 'a t list -> 'a t
+Append sequences. Iterating on the result is like iterating + on the each sequence of the list in order.
+Since 0.11
+
+ 
val concat : 'a t t -> 'a t
Concatenate a sequence of sequences into one sequence.
@@ -290,12 +296,29 @@ Convenience function combining val 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
+seq_list_map f l maps f over every element of l, + then calls Sequence.seq_list
+Since 0.11
+
+ 
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
+Similar to Sequence.zip_i but returns a normal sequence of tuples
+Since 0.11
+
+ 
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
Same as SequenceLabels.IO.write_to, but intercales '\n' between each string
-
val write_bytes_lines : ?mode:int ->
       ?flags:Pervasives.open_flag list ->
       string -> Bytes.t SequenceLabels.t -> unit
\ No newline at end of file +
val write_bytes_lines : ?mode:int ->
       ?flags:Pervasives.open_flag list ->
       string -> Bytes.t SequenceLabels.t -> unit
+Since 0.5.4
+
+ \ No newline at end of file diff --git a/api/SequenceLabels.Infix.html b/api/SequenceLabels.Infix.html index 9fe69a2..f483099 100644 --- a/api/SequenceLabels.Infix.html +++ b/api/SequenceLabels.Infix.html @@ -38,17 +38,21 @@ 
val (>>=) : 'a SequenceLabels.t -> ('a -> 'b SequenceLabels.t) -> 'b SequenceLabels.t
Monadic bind (infix version of SequenceLabels.flat_map
+Since 0.5
val (>|=) : 'a SequenceLabels.t -> ('a -> 'b) -> 'b SequenceLabels.t
Infix version of SequenceLabels.map
+Since 0.5
val (<*>) : ('a -> 'b) SequenceLabels.t -> 'a SequenceLabels.t -> 'b SequenceLabels.t
Applicative operator (product+application)
+Since 0.5
val (<+>) : 'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
Concatenation of sequences
+Since 0.5
\ No newline at end of file diff --git a/api/SequenceLabels.html b/api/SequenceLabels.html index 2b0dc12..0f56ce8 100644 --- a/api/SequenceLabels.html +++ b/api/SequenceLabels.html @@ -59,6 +59,12 @@ A sequence of values of type 'a. If you give it a func Sequence of pairs of values of type 'a and 'b.
+ +
type 'a equal = 'a -> 'a -> bool
+ + +
type 'a hash = 'a -> int
+

Build a sequence


@@ -183,11 +189,18 @@ Exists there some element satisfying the predicate?
val mem : ?eq:('a -> 'a -> bool) -> x:'a -> 'a t -> bool
Is the value a member of the sequence?
+Since 0.5
eq : the equality predicate to use (default (=))
-
val find : f:('a -> 'b option) -> 'a t -> 'b option
+
val find : ('a -> 'b option) -> 'a t -> 'b option
Find the first element on which the function doesn't return None
+Since 0.5
+
+ +
val find_map : f:('a -> 'b option) -> 'a t -> 'b option
+Alias to SequenceLabels.find
+Since 0.10
val findi : f:(int -> 'a -> 'b option) -> 'a t -> 'b option
@@ -195,6 +208,11 @@ Indexed version of Sequ Since 0.9
+
val find_mapi : f:(int -> 'a -> 'b option) -> 'a t -> 'b option
+Alias to SequenceLabels.findi
+Since 0.10
+
+ 
val find_pred : f:('a -> bool) -> 'a t -> 'a option
find_pred p l finds the first element of l that satisfies p, or returns None if no element satisfies p
@@ -226,6 +244,12 @@ Append two sequences. Iterating on the result is like iterating on the first, then on the second.
+
val append_l : 'a t list -> 'a t
+Append sequences. Iterating on the result is like iterating + on the each sequence of the list in order.
+Since 0.11
+
+ 
val concat : 'a t t -> 'a t
Concatenate a sequence of sequences into one sequence.
@@ -247,6 +271,23 @@ Convenience function combining fmap with a more explicit name
+
val filter_mapi : f:(int -> 'a -> 'b option) -> 'a t -> 'b t
+Map with indices, and only keep non-None elements
+Since 0.11
+
+ +
val 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 : f:('a -> 'b t) -> 'a list -> 'b list t
+seq_list_map f l maps f over every element of l, + then calls SequenceLabels.seq_list
+Since 0.11
+
+ 
val intersperse : x:'a -> 'a t -> 'a t
Insert the single element between every element of the sequence
@@ -298,7 +339,8 @@ Group equal consecutive elements. 
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
@@ -334,6 +376,7 @@ All pairs of distinct positions of the sequence. 
val product2 : 'a t -> 'b t -> ('a, 'b) t2
Binary version of SequenceLabels.product. Same requirements.
+Since 0.5
val join : join_row:('a -> 'b -> 'c option) ->
       'a t -> 'b t -> 'c t
@@ -343,6 +386,67 @@ Binary version of Se iterations.
+
val join_by : ?eq:'key equal ->
       ?hash:'key hash ->
       ('a -> 'key) ->
       ('b -> 'key) ->
       merge:('key -> 'a -> 'b -> 'c option) ->
       'a t -> 'b t -> 'c t
+join key1 key2 ~merge is a binary operation + that takes two sequences a and b, projects their + 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. + precondition: for any x and y, if eq x y then hash x=hash y must hold.
+Since 0.10
+
+ +
val join_all_by : ?eq:'key equal ->
       ?hash:'key hash ->
       ('a -> 'key) ->
       ('b -> 'key) ->
       merge:('key -> 'a list -> 'b list -> 'c option) ->
       'a t -> 'b t -> 'c t
+join_all_by key1 key2 ~merge is a binary operation + that takes two sequences a and b, projects their + elements resp. with key1 and key2, and, for each key k + occurring in at least one of them:
    +
  • compute the list l1 of elements of a that map to k
    • +
  • compute the list l2 of elements of b that map to k
    • +
  • call merge k l1 l2. If merge returns None, the combination + of values is discarded, otherwise it returns Some c + and c is inserted in the result.
    • +
+
+Since 0.10
+
+ +
val group_join_by : ?eq:'a equal ->
       ?hash:'a hash ->
       ('b -> 'a) ->
       'a t -> 'b t -> ('a * 'b list) t
+group_join_by key2 associates to every element x of + 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 [] + 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. + 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. + precondition: for any x and y, if eq x y then hash x=hash y must hold.
+Since 0.10
+
+ +
val diff : ?eq:'a equal ->
       ?hash:'a hash ->
       'a t -> 'a t -> 'a t
+Set difference. Eager.
+Since 0.10
+
+ +
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. + precondition: for any x and y, if eq x y then hash x=hash y must hold.
+Since 0.10
+
+ 
val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a t
unfoldr f b will apply f to b. If it yields Some (x,b') then x is returned @@ -359,17 +463,41 @@ Max element of the sequence, using the given comparison function.
element otherwise
+
val max_exn : ?lt:('a -> 'a -> bool) -> 'a t -> 'a
+Unsafe version of SequenceLabels.max
+Since 0.10
+Raises Not_found if the sequence is empty
+
+ 
val min : ?lt:('a -> 'a -> bool) -> 'a t -> 'a option
Min element of the sequence, using the given comparison function. see SequenceLabels.max for more details.
+
val min_exn : ?lt:('a -> 'a -> bool) -> 'a t -> 'a
+Unsafe version of SequenceLabels.min
+Since 0.10
+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
val head_exn : 'a t -> 'a
First element, if any, fails
+Since 0.5.1
Raises Invalid_argument if the sequence is empty
@@ -387,6 +515,7 @@ Take elements while they satisfy the predicate, then stops iterating. 
val fold_while : f:('a -> 'b -> 'a * [ `Continue | `Stop ]) ->
       init:'a -> 'b t -> 'a
Folds over elements of the sequence, stopping early if the accumulator returns ('a, `Stop)
+Since 0.5.5
val drop : int -> 'a t -> 'a t
@@ -436,10 +565,17 @@ Get the list of the reversed sequence (more efficient than val of_list : 'a list -> 'a t 
val on_list : ('a t -> 'b t) -> 'a list -> 'b list
on_list f l is equivalent to to_list @@ f @@ of_list l.
+Since 0.5.2
+
+ +
val pair_with_idx : 'a t -> (int * 'a) t
+Similar to SequenceLabels.zip_i but returns a normal sequence of tuples
+Since 0.11
val to_opt : 'a t -> 'a option
Alias to SequenceLabels.head
+Since 0.5.1
val to_array : 'a t -> 'a array
@@ -460,6 +596,7 @@ Elements of the array, with their index
val of_opt : 'a option -> 'a t
Iterate on 0 or 1 values.
+Since 0.5.1
val of_stream : 'a Stream.t -> 'a t
@@ -519,6 +656,7 @@ Sequence of key/value pairs from the hashtable
val concat_str : string t -> string
Concatenate strings together, eagerly. Also see SequenceLabels.intersperse to add a separator.
+Since 0.5
exception OneShotSequence
diff --git a/api/html.stamp b/api/html.stamp index 0f61c54..68ed6d1 100644 --- a/api/html.stamp +++ b/api/html.stamp @@ -1 +1 @@ -01e4b44957fc72253f7d3ad77531bb1e \ No newline at end of file +70c0e7d0d0f1803f43e8d143c98b447b \ No newline at end of file diff --git a/api/index_types.html b/api/index_types.html index 8808614..b9e1784 100644 --- a/api/index_types.html +++ b/api/index_types.html @@ -18,6 +18,8 @@

Index of types

+ + @@ -26,6 +28,8 @@ + + diff --git a/api/index_values.html b/api/index_values.html index 8b1d567..3cdbc60 100644 --- a/api/index_values.html +++ b/api/index_values.html @@ -93,6 +93,16 @@ Append two sequences. Append two sequences. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - +

E
equal [SequenceLabels]
equal [Sequence]

G
gen [Sequence]

H
hash [SequenceLabels]
hash [Sequence]

K
append_l [SequenceLabels]
+Append sequences. +
+
append_l [Sequence]
+Append sequences. +
+
array_slice [SequenceLabels]
array_slice a i j Sequence of elements whose indexes range @@ -198,6 +208,11 @@ All pairs of distinct positions of the list. All pairs of distinct positions of the list.
diff [SequenceLabels]
+Set difference. +
+
diff [Sequence]
Set difference. @@ -280,6 +295,16 @@ Map and only keep non-None elements Formerly fmap
filter_mapi [SequenceLabels]
+Map with indices, and only keep non-None elements +
+
filter_mapi [Sequence]
+Map with indices, and only keep non-None elements +
+
find [SequenceLabels]
Find the first element on which the function doesn't return None @@ -290,11 +315,21 @@ Find the first element on which the function doesn't return N Find the first element on which the function doesn't return None
find_map [SequenceLabels]
+Alias to SequenceLabels.find +
+
find_map [Sequence]
Alias to Sequence.find
find_mapi [SequenceLabels]
+Alias to SequenceLabels.findi +
+
find_mapi [Sequence]
Alias to Sequence.findi @@ -473,6 +508,13 @@ Group equal elements, disregarding their order of appearance. Group equal elements, disregarding their order of appearance.
group_join_by [SequenceLabels]
+group_join_by key2 associates to every element x of + the first sequence, all the elements y of the second + sequence such that eq x (key y). +
+
group_join_by [Sequence]
group_join_by key2 associates to every element x of @@ -586,6 +628,11 @@ Iterator on decreasing integers in stop...start by ste Iterator on decreasing integers in stop...start by steps -1.
inter [SequenceLabels]
+Intersection of two collections. +
+
inter [Sequence]
Intersection of two collections. @@ -662,6 +709,13 @@ Iterate on elements and their index in the sequence element of b using join_row.
join_all_by [SequenceLabels]
+join_all_by key1 key2 ~merge is a binary operation + that takes two sequences a and b, projects their + elements resp. +
+
join_all_by [Sequence]
join_all_by key1 key2 ~merge is a binary operation @@ -669,6 +723,13 @@ Iterate on elements and their index in the sequence elements resp.
join_by [SequenceLabels]
+join key1 key2 ~merge is a binary operation + that takes two sequences a and b, projects their + elements resp. +
+
join_by [Sequence]
join key1 key2 ~merge is a binary operation @@ -761,6 +822,11 @@ Max element of the sequence, using the given comparison function. Max element of the sequence, using the given comparison function.
max_exn [SequenceLabels]
+Unsafe version of SequenceLabels.max +
+
max_exn [Sequence]
Unsafe version of Sequence.max @@ -786,6 +852,11 @@ Min element of the sequence, using the given comparison function. Min element of the sequence, using the given comparison function.
min_exn [SequenceLabels]
+Unsafe version of SequenceLabels.min +
+
min_exn [Sequence]
Unsafe version of Sequence.min @@ -947,6 +1018,16 @@ Sequence of elements of a stream (usable only once)

P
pair_with_idx [SequenceLabels]
+Similar to SequenceLabels.zip_i but returns a normal sequence of tuples +
+
pair_with_idx [Sequence]
+Similar to Sequence.zip_i but returns a normal sequence of tuples +
+
persistent [SequenceLabels]
Iterate on the sequence, storing elements in an efficient internal structure.. @@ -1117,6 +1198,30 @@ Sequence of intermediate results Sequence of intermediate results
seq_list [SequenceLabels]
+seq_list l returns all the ways to pick one element in each sub-sequence + in l. +
+
seq_list [Sequence]
+seq_list l returns all the ways to pick one element in each sub-sequence + in l. +
+
seq_list_map [SequenceLabels]
+seq_list_map f l maps f over every element of l, + then calls SequenceLabels.seq_list +
+
seq_list_map [Sequence]
+seq_list_map f l maps f over every element of l, + then calls Sequence.seq_list +
+
shuffle [SequenceLabels]
shuffle seq returns a perfect shuffle of seq. @@ -1189,11 +1294,36 @@ Checks whether the sequence is sorted. Checks whether the sequence is sorted.
subset [SequenceLabels]
+subset a b returns true if all elements of a belong to b. +
+
subset [Sequence]
subset a b returns true if all elements of a belong to b.
sum [SequenceLabels]
+Sum of elements +
+
sum [Sequence]
+Sum of elements +
+
sumf [SequenceLabels]
+Sum of elements, using Kahan summation +
+
sumf [Sequence]
+Sum of elements, using Kahan summation +
+

T
take [SequenceLabels]
@@ -1386,6 +1516,11 @@ Print into a string unfoldr f b will apply f to b.
union [SequenceLabels]
+Union of two collections. +
+
union [Sequence]
Union of two collections. @@ -1412,7 +1547,9 @@ Remove consecutive duplicate elements.

W
write_bytes_lines [SequenceLabels.IO]
+
+
write_bytes_lines [Sequence.IO]
diff --git a/api/style.css b/api/style.css index a5b4578..d8a7615 100644 --- a/api/style.css +++ b/api/style.css @@ -31,7 +31,7 @@ pre.verbatim, pre.codepre { } .indextable {border: 1px #ddd solid; border-collapse: collapse} .indextable td, .indextable th {border: 1px #ddd solid; min-width: 80px} .indextable td.module {background-color: #eee ; padding-left: 2px; padding-right: 2px} -.indextable td.module a {color: 4E6272; text-decoration: none; display: block; width: 100%} +.indextable td.module a {color: #4E6272; text-decoration: none; display: block; width: 100%} .indextable td.module a:hover {text-decoration: underline; background-color: transparent} .deprecated {color: #888; font-style: italic} .indextable tr td div.info { margin-left: 2px; margin-right: 2px } diff --git a/api/type_Sequence.Map.Adapt.html b/api/type_Sequence.Map.Adapt.html index 7c7f5d4..272a74e 100644 --- a/api/type_Sequence.Map.Adapt.html +++ b/api/type_Sequence.Map.Adapt.html @@ -36,10 +36,18 @@     val cardinal : 'a t -> int
    val bindings : 'a t -> (key * 'a) list
    val min_binding : 'a t -> key * 'a
+    val min_binding_opt : 'a t -> (key * 'a) option
    val max_binding : 'a t -> key * 'a
+    val max_binding_opt : 'a t -> (key * 'a) option
    val choose : 'a t -> key * 'a
+    val choose_opt : 'a t -> (key * 'a) option
    val split : key -> 'a t -> 'a t * 'a option * 'a t
    val find : key -> 'a t -> 'a
+    val find_opt : key -> 'a t -> 'a option
+    val find_first : (key -> bool) -> 'a t -> key * 'a
+    val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+    val find_last : (key -> bool) -> 'a t -> key * 'a
+    val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
    val map : ('a -> 'b) -> 'a t -> 'b t
    val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
    val to_seq : 'a t -> (key * 'a) sequence
diff --git a/api/type_Sequence.Map.Make.html b/api/type_Sequence.Map.Make.html index dd7ef04..a1021b0 100644 --- a/api/type_Sequence.Map.Make.html +++ b/api/type_Sequence.Map.Make.html @@ -36,10 +36,18 @@     val cardinal : 'a t -> int
    val bindings : 'a t -> (key * 'a) list
    val min_binding : 'a t -> key * 'a
+    val min_binding_opt : 'a t -> (key * 'a) option
    val max_binding : 'a t -> key * 'a
+    val max_binding_opt : 'a t -> (key * 'a) option
    val choose : 'a t -> key * 'a
+    val choose_opt : 'a t -> (key * 'a) option
    val split : key -> 'a t -> 'a t * 'a option * 'a t
    val find : key -> 'a t -> 'a
+    val find_opt : key -> 'a t -> 'a option
+    val find_first : (key -> bool) -> 'a t -> key * 'a
+    val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+    val find_last : (key -> bool) -> 'a t -> key * 'a
+    val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
    val map : ('a -> 'b) -> 'a t -> 'b t
    val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
    val to_seq : 'a t -> (key * 'a) sequence
diff --git a/api/type_Sequence.Map.S.html b/api/type_Sequence.Map.S.html index 5c7eff9..0d179c2 100644 --- a/api/type_Sequence.Map.S.html +++ b/api/type_Sequence.Map.S.html @@ -35,10 +35,18 @@   val cardinal : 'a t -> int
  val bindings : 'a t -> (key * 'a) list
  val min_binding : 'a t -> key * 'a
+  val min_binding_opt : 'a t -> (key * 'a) option
  val max_binding : 'a t -> key * 'a
+  val max_binding_opt : 'a t -> (key * 'a) option
  val choose : 'a t -> key * 'a
+  val choose_opt : 'a t -> (key * 'a) option
  val split : key -> 'a t -> 'a t * 'a option * 'a t
  val find : key -> 'a t -> 'a
+  val find_opt : key -> 'a t -> 'a option
+  val find_first : (key -> bool) -> 'a t -> key * 'a
+  val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+  val find_last : (key -> bool) -> 'a t -> key * 'a
+  val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
  val map : ('a -> 'b) -> 'a t -> 'b t
  val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
  val to_seq : 'a Sequence.t -> (key * 'a) Sequence.sequence
diff --git a/api/type_Sequence.Map.html b/api/type_Sequence.Map.html index 04cea8a..7b8f21d 100644 --- a/api/type_Sequence.Map.html +++ b/api/type_Sequence.Map.html @@ -37,10 +37,18 @@       val cardinal : 'a t -> int
      val bindings : 'a t -> (key * 'a) list
      val min_binding : 'a t -> key * 'a
+      val min_binding_opt : 'a t -> (key * 'a) option
      val max_binding : 'a t -> key * 'a
+      val max_binding_opt : 'a t -> (key * 'a) option
      val choose : 'a t -> key * 'a
+      val choose_opt : 'a t -> (key * 'a) option
      val split : key -> 'a t -> 'a t * 'a option * 'a t
      val find : key -> 'a t -> 'a
+      val find_opt : key -> 'a t -> 'a option
+      val find_first : (key -> bool) -> 'a t -> key * 'a
+      val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+      val find_last : (key -> bool) -> 'a t -> key * 'a
+      val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
      val map : ('a -> 'b) -> 'a t -> 'b t
      val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
      val to_seq : 'a Sequence.t -> (key * 'a) Sequence.sequence
@@ -76,10 +84,18 @@         val cardinal : 'a t -> int
        val bindings : 'a t -> (key * 'a) list
        val min_binding : 'a t -> key * 'a
+        val min_binding_opt : 'a t -> (key * 'a) option
        val max_binding : 'a t -> key * 'a
+        val max_binding_opt : 'a t -> (key * 'a) option
        val choose : 'a t -> key * 'a
+        val choose_opt : 'a t -> (key * 'a) option
        val split : key -> 'a t -> 'a t * 'a option * 'a t
        val find : key -> 'a t -> 'a
+        val find_opt : key -> 'a t -> 'a option
+        val find_first : (key -> bool) -> 'a t -> key * 'a
+        val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+        val find_last : (key -> bool) -> 'a t -> key * 'a
+        val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
        val map : ('a -> 'b) -> 'a t -> 'b t
        val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
        val to_seq : 'a t -> (key * 'a) sequence
@@ -115,10 +131,18 @@         val cardinal : 'a t -> int
        val bindings : 'a t -> (key * 'a) list
        val min_binding : 'a t -> key * 'a
+        val min_binding_opt : 'a t -> (key * 'a) option
        val max_binding : 'a t -> key * 'a
+        val max_binding_opt : 'a t -> (key * 'a) option
        val choose : 'a t -> key * 'a
+        val choose_opt : 'a t -> (key * 'a) option
        val split : key -> 'a t -> 'a t * 'a option * 'a t
        val find : key -> 'a t -> 'a
+        val find_opt : key -> 'a t -> 'a option
+        val find_first : (key -> bool) -> 'a t -> key * 'a
+        val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+        val find_last : (key -> bool) -> 'a t -> key * 'a
+        val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
        val map : ('a -> 'b) -> 'a t -> 'b t
        val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
        val to_seq : 'a t -> (key * 'a) sequence
diff --git a/api/type_Sequence.Set.Adapt.html b/api/type_Sequence.Set.Adapt.html index aa48f34..8aa5abe 100644 --- a/api/type_Sequence.Set.Adapt.html +++ b/api/type_Sequence.Set.Adapt.html @@ -38,10 +38,18 @@     val cardinal : t -> int
    val elements : t -> elt list
    val min_elt : t -> elt
+    val min_elt_opt : t -> elt option
    val max_elt : t -> elt
+    val max_elt_opt : t -> elt option
    val choose : t -> elt
+    val choose_opt : t -> elt option
    val split : elt -> t -> t * bool * t
    val find : elt -> t -> elt
+    val find_opt : elt -> t -> elt option
+    val find_first : (elt -> bool) -> t -> elt
+    val find_first_opt : (elt -> bool) -> t -> elt option
+    val find_last : (elt -> bool) -> t -> elt
+    val find_last_opt : (elt -> bool) -> t -> elt option
    val of_seq : elt sequence -> t
    val to_seq : t -> elt sequence
    val to_list : t -> elt list
diff --git a/api/type_Sequence.Set.Make.html b/api/type_Sequence.Set.Make.html index f01fac9..ab6713f 100644 --- a/api/type_Sequence.Set.Make.html +++ b/api/type_Sequence.Set.Make.html @@ -38,10 +38,18 @@     val cardinal : t -> int
    val elements : t -> elt list
    val min_elt : t -> elt
+    val min_elt_opt : t -> elt option
    val max_elt : t -> elt
+    val max_elt_opt : t -> elt option
    val choose : t -> elt
+    val choose_opt : t -> elt option
    val split : elt -> t -> t * bool * t
    val find : elt -> t -> elt
+    val find_opt : elt -> t -> elt option
+    val find_first : (elt -> bool) -> t -> elt
+    val find_first_opt : (elt -> bool) -> t -> elt option
+    val find_last : (elt -> bool) -> t -> elt
+    val find_last_opt : (elt -> bool) -> t -> elt option
    val of_seq : elt sequence -> t
    val to_seq : t -> elt sequence
    val to_list : t -> elt list
diff --git a/api/type_Sequence.Set.S.html b/api/type_Sequence.Set.S.html index 7676b02..97a082d 100644 --- a/api/type_Sequence.Set.S.html +++ b/api/type_Sequence.Set.S.html @@ -37,10 +37,18 @@   val cardinal : t -> int
  val elements : t -> elt list
  val min_elt : t -> elt
+  val min_elt_opt : t -> elt option
  val max_elt : t -> elt
+  val max_elt_opt : t -> elt option
  val choose : t -> elt
+  val choose_opt : t -> elt option
  val split : elt -> t -> t * bool * t
  val find : elt -> t -> elt
+  val find_opt : elt -> t -> elt option
+  val find_first : (elt -> bool) -> t -> elt
+  val find_first_opt : (elt -> bool) -> t -> elt option
+  val find_last : (elt -> bool) -> t -> elt
+  val find_last_opt : (elt -> bool) -> t -> elt option
  val of_seq : elt Sequence.sequence -> Sequence.t
  val to_seq : Sequence.t -> elt Sequence.sequence
  val to_list : Sequence.t -> elt list
diff --git a/api/type_Sequence.Set.html b/api/type_Sequence.Set.html index eeae71d..cd974ef 100644 --- a/api/type_Sequence.Set.html +++ b/api/type_Sequence.Set.html @@ -39,10 +39,18 @@       val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
+      val min_elt_opt : t -> elt option
      val max_elt : t -> elt
+      val max_elt_opt : t -> elt option
      val choose : t -> elt
+      val choose_opt : t -> elt option
      val split : elt -> t -> t * bool * t
      val find : elt -> t -> elt
+      val find_opt : elt -> t -> elt option
+      val find_first : (elt -> bool) -> t -> elt
+      val find_first_opt : (elt -> bool) -> t -> elt option
+      val find_last : (elt -> bool) -> t -> elt
+      val find_last_opt : (elt -> bool) -> t -> elt option
      val of_seq : elt Sequence.sequence -> Sequence.t
      val to_seq : Sequence.t -> elt Sequence.sequence
      val to_list : Sequence.t -> elt list
@@ -75,10 +83,18 @@         val cardinal : t -> int
        val elements : t -> elt list
        val min_elt : t -> elt
+        val min_elt_opt : t -> elt option
        val max_elt : t -> elt
+        val max_elt_opt : t -> elt option
        val choose : t -> elt
+        val choose_opt : t -> elt option
        val split : elt -> t -> t * bool * t
        val find : elt -> t -> elt
+        val find_opt : elt -> t -> elt option
+        val find_first : (elt -> bool) -> t -> elt
+        val find_first_opt : (elt -> bool) -> t -> elt option
+        val find_last : (elt -> bool) -> t -> elt
+        val find_last_opt : (elt -> bool) -> t -> elt option
        val of_seq : elt sequence -> t
        val to_seq : t -> elt sequence
        val to_list : t -> elt list
@@ -111,10 +127,18 @@         val cardinal : t -> int
        val elements : t -> elt list
        val min_elt : t -> elt
+        val min_elt_opt : t -> elt option
        val max_elt : t -> elt
+        val max_elt_opt : t -> elt option
        val choose : t -> elt
+        val choose_opt : t -> elt option
        val split : elt -> t -> t * bool * t
        val find : elt -> t -> elt
+        val find_opt : elt -> t -> elt option
+        val find_first : (elt -> bool) -> t -> elt
+        val find_first_opt : (elt -> bool) -> t -> elt option
+        val find_last : (elt -> bool) -> t -> elt
+        val find_last_opt : (elt -> bool) -> t -> elt option
        val of_seq : elt sequence -> t
        val to_seq : t -> elt sequence
        val to_list : t -> elt list
diff --git a/api/type_Sequence.html b/api/type_Sequence.html index b03e143..155c6d1 100644 --- a/api/type_Sequence.html +++ b/api/type_Sequence.html @@ -57,11 +57,16 @@   val is_empty : 'a Sequence.t -> bool
  val filter : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
  val append : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
+  val append_l : 'a Sequence.t list -> 'a Sequence.t
  val concat : 'a Sequence.t Sequence.t -> 'a Sequence.t
  val flatten : 'a Sequence.t Sequence.t -> 'a Sequence.t
  val flat_map : ('a -> 'b Sequence.t) -> 'a Sequence.t -> 'b Sequence.t
  val flat_map_l : ('a -> 'b list) -> 'a Sequence.t -> 'b Sequence.t
+  val seq_list : 'a Sequence.t list -> 'a list Sequence.t
+  val seq_list_map : ('a -> 'b Sequence.t) -> 'a list -> 'b list Sequence.t
  val filter_map : ('a -> 'b option) -> 'a Sequence.t -> 'b Sequence.t
+  val filter_mapi :
+    (int -> 'a -> 'b option) -> 'a Sequence.t -> 'b Sequence.t
  val intersperse : 'a -> 'a Sequence.t -> 'a Sequence.t
  val persistent : 'a Sequence.t -> 'a Sequence.t
  val persistent_lazy : 'a Sequence.t -> 'a Sequence.t
@@ -120,6 +125,8 @@   val max_exn : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a
  val min : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a option
  val min_exn : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a
+  val sum : int Sequence.t -> int
+  val sumf : float Sequence.t -> float
  val head : 'a Sequence.t -> 'a option
  val head_exn : 'a Sequence.t -> 'a
  val take : int -> 'a Sequence.t -> 'a Sequence.t
@@ -145,6 +152,7 @@   val to_rev_list : 'a Sequence.t -> 'a list
  val of_list : 'a list -> 'a Sequence.t
  val on_list : ('a Sequence.t -> 'b Sequence.t) -> 'a list -> 'b list
+  val pair_with_idx : 'a Sequence.t -> (int * 'a) Sequence.t
  val to_opt : 'a Sequence.t -> 'a option
  val to_array : 'a Sequence.t -> 'a array
  val of_array : 'a array -> 'a Sequence.t
@@ -214,10 +222,18 @@           val cardinal : t -> int
          val elements : t -> elt list
          val min_elt : t -> elt
+          val min_elt_opt : t -> elt option
          val max_elt : t -> elt
+          val max_elt_opt : t -> elt option
          val choose : t -> elt
+          val choose_opt : t -> elt option
          val split : elt -> t -> t * bool * t
          val find : elt -> t -> elt
+          val find_opt : elt -> t -> elt option
+          val find_first : (elt -> bool) -> t -> elt
+          val find_first_opt : (elt -> bool) -> t -> elt option
+          val find_last : (elt -> bool) -> t -> elt
+          val find_last_opt : (elt -> bool) -> t -> elt option
          val of_seq : elt Sequence.sequence -> Sequence.t
          val to_seq : Sequence.t -> elt Sequence.sequence
          val to_list : Sequence.t -> elt list
@@ -250,10 +266,18 @@             val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
+            val min_elt_opt : t -> elt option
            val max_elt : t -> elt
+            val max_elt_opt : t -> elt option
            val choose : t -> elt
+            val choose_opt : t -> elt option
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
+            val find_opt : elt -> t -> elt option
+            val find_first : (elt -> bool) -> t -> elt
+            val find_first_opt : (elt -> bool) -> t -> elt option
+            val find_last : (elt -> bool) -> t -> elt
+            val find_last_opt : (elt -> bool) -> t -> elt option
            val of_seq : elt sequence -> t
            val to_seq : t -> elt sequence
            val to_list : t -> elt list
@@ -286,10 +310,18 @@             val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
+            val min_elt_opt : t -> elt option
            val max_elt : t -> elt
+            val max_elt_opt : t -> elt option
            val choose : t -> elt
+            val choose_opt : t -> elt option
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
+            val find_opt : elt -> t -> elt option
+            val find_first : (elt -> bool) -> t -> elt
+            val find_first_opt : (elt -> bool) -> t -> elt option
+            val find_last : (elt -> bool) -> t -> elt
+            val find_last_opt : (elt -> bool) -> t -> elt option
            val of_seq : elt sequence -> t
            val to_seq : t -> elt sequence
            val to_list : t -> elt list
@@ -323,10 +355,18 @@           val cardinal : 'a t -> int
          val bindings : 'a t -> (key * 'a) list
          val min_binding : 'a t -> key * 'a
+          val min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
+          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
+          val choose_opt : 'a t -> (key * 'a) option
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
+          val find_opt : key -> 'a t -> 'a option
+          val find_first : (key -> bool) -> 'a t -> key * 'a
+          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+          val find_last : (key -> bool) -> 'a t -> key * 'a
+          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val map : ('a -> 'b) -> 'a t -> 'b t
          val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
          val to_seq : 'a Sequence.t -> (key * 'a) Sequence.sequence
@@ -363,10 +403,18 @@             val cardinal : 'a t -> int
            val bindings : 'a t -> (key * 'a) list
            val min_binding : 'a t -> key * 'a
+            val min_binding_opt : 'a t -> (key * 'a) option
            val max_binding : 'a t -> key * 'a
+            val max_binding_opt : 'a t -> (key * 'a) option
            val choose : 'a t -> key * 'a
+            val choose_opt : 'a t -> (key * 'a) option
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
+            val find_opt : key -> 'a t -> 'a option
+            val find_first : (key -> bool) -> 'a t -> key * 'a
+            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+            val find_last : (key -> bool) -> 'a t -> key * 'a
+            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val map : ('a -> 'b) -> 'a t -> 'b t
            val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
            val to_seq : 'a t -> (key * 'a) sequence
@@ -403,10 +451,18 @@             val cardinal : 'a t -> int
            val bindings : 'a t -> (key * 'a) list
            val min_binding : 'a t -> key * 'a
+            val min_binding_opt : 'a t -> (key * 'a) option
            val max_binding : 'a t -> key * 'a
+            val max_binding_opt : 'a t -> (key * 'a) option
            val choose : 'a t -> key * 'a
+            val choose_opt : 'a t -> (key * 'a) option
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
+            val find_opt : key -> 'a t -> 'a option
+            val find_first : (key -> bool) -> 'a t -> key * 'a
+            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+            val find_last : (key -> bool) -> 'a t -> key * 'a
+            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val map : ('a -> 'b) -> 'a t -> 'b t
            val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
            val to_seq : 'a t -> (key * 'a) sequence
diff --git a/api/type_SequenceLabels.Map.Adapt.html b/api/type_SequenceLabels.Map.Adapt.html index 5f4e5da..b678040 100644 --- a/api/type_SequenceLabels.Map.Adapt.html +++ b/api/type_SequenceLabels.Map.Adapt.html @@ -36,10 +36,18 @@     val cardinal : 'a t -> int
    val bindings : 'a t -> (key * 'a) list
    val min_binding : 'a t -> key * 'a
+    val min_binding_opt : 'a t -> (key * 'a) option
    val max_binding : 'a t -> key * 'a
+    val max_binding_opt : 'a t -> (key * 'a) option
    val choose : 'a t -> key * 'a
+    val choose_opt : 'a t -> (key * 'a) option
    val split : key -> 'a t -> 'a t * 'a option * 'a t
    val find : key -> 'a t -> 'a
+    val find_opt : key -> 'a t -> 'a option
+    val find_first : (key -> bool) -> 'a t -> key * 'a
+    val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+    val find_last : (key -> bool) -> 'a t -> key * 'a
+    val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
    val map : ('a -> 'b) -> 'a t -> 'b t
    val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
    val to_seq : 'a t -> (key * 'a) sequence
diff --git a/api/type_SequenceLabels.Map.Make.html b/api/type_SequenceLabels.Map.Make.html index 47fa995..1fd146f 100644 --- a/api/type_SequenceLabels.Map.Make.html +++ b/api/type_SequenceLabels.Map.Make.html @@ -36,10 +36,18 @@     val cardinal : 'a t -> int
    val bindings : 'a t -> (key * 'a) list
    val min_binding : 'a t -> key * 'a
+    val min_binding_opt : 'a t -> (key * 'a) option
    val max_binding : 'a t -> key * 'a
+    val max_binding_opt : 'a t -> (key * 'a) option
    val choose : 'a t -> key * 'a
+    val choose_opt : 'a t -> (key * 'a) option
    val split : key -> 'a t -> 'a t * 'a option * 'a t
    val find : key -> 'a t -> 'a
+    val find_opt : key -> 'a t -> 'a option
+    val find_first : (key -> bool) -> 'a t -> key * 'a
+    val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+    val find_last : (key -> bool) -> 'a t -> key * 'a
+    val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
    val map : ('a -> 'b) -> 'a t -> 'b t
    val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
    val to_seq : 'a t -> (key * 'a) sequence
diff --git a/api/type_SequenceLabels.Map.S.html b/api/type_SequenceLabels.Map.S.html index 15a9b05..ce91ffc 100644 --- a/api/type_SequenceLabels.Map.S.html +++ b/api/type_SequenceLabels.Map.S.html @@ -35,10 +35,18 @@   val cardinal : 'a t -> int
  val bindings : 'a t -> (key * 'a) list
  val min_binding : 'a t -> key * 'a
+  val min_binding_opt : 'a t -> (key * 'a) option
  val max_binding : 'a t -> key * 'a
+  val max_binding_opt : 'a t -> (key * 'a) option
  val choose : 'a t -> key * 'a
+  val choose_opt : 'a t -> (key * 'a) option
  val split : key -> 'a t -> 'a t * 'a option * 'a t
  val find : key -> 'a t -> 'a
+  val find_opt : key -> 'a t -> 'a option
+  val find_first : (key -> bool) -> 'a t -> key * 'a
+  val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+  val find_last : (key -> bool) -> 'a t -> key * 'a
+  val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
  val map : ('a -> 'b) -> 'a t -> 'b t
  val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
  val to_seq : 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
diff --git a/api/type_SequenceLabels.Map.html b/api/type_SequenceLabels.Map.html index f7f1675..510cea3 100644 --- a/api/type_SequenceLabels.Map.html +++ b/api/type_SequenceLabels.Map.html @@ -37,10 +37,18 @@       val cardinal : 'a t -> int
      val bindings : 'a t -> (key * 'a) list
      val min_binding : 'a t -> key * 'a
+      val min_binding_opt : 'a t -> (key * 'a) option
      val max_binding : 'a t -> key * 'a
+      val max_binding_opt : 'a t -> (key * 'a) option
      val choose : 'a t -> key * 'a
+      val choose_opt : 'a t -> (key * 'a) option
      val split : key -> 'a t -> 'a t * 'a option * 'a t
      val find : key -> 'a t -> 'a
+      val find_opt : key -> 'a t -> 'a option
+      val find_first : (key -> bool) -> 'a t -> key * 'a
+      val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+      val find_last : (key -> bool) -> 'a t -> key * 'a
+      val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
      val map : ('a -> 'b) -> 'a t -> 'b t
      val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
      val to_seq : 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
@@ -76,10 +84,18 @@         val cardinal : 'a t -> int
        val bindings : 'a t -> (key * 'a) list
        val min_binding : 'a t -> key * 'a
+        val min_binding_opt : 'a t -> (key * 'a) option
        val max_binding : 'a t -> key * 'a
+        val max_binding_opt : 'a t -> (key * 'a) option
        val choose : 'a t -> key * 'a
+        val choose_opt : 'a t -> (key * 'a) option
        val split : key -> 'a t -> 'a t * 'a option * 'a t
        val find : key -> 'a t -> 'a
+        val find_opt : key -> 'a t -> 'a option
+        val find_first : (key -> bool) -> 'a t -> key * 'a
+        val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+        val find_last : (key -> bool) -> 'a t -> key * 'a
+        val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
        val map : ('a -> 'b) -> 'a t -> 'b t
        val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
        val to_seq : 'a t -> (key * 'a) sequence
@@ -115,10 +131,18 @@         val cardinal : 'a t -> int
        val bindings : 'a t -> (key * 'a) list
        val min_binding : 'a t -> key * 'a
+        val min_binding_opt : 'a t -> (key * 'a) option
        val max_binding : 'a t -> key * 'a
+        val max_binding_opt : 'a t -> (key * 'a) option
        val choose : 'a t -> key * 'a
+        val choose_opt : 'a t -> (key * 'a) option
        val split : key -> 'a t -> 'a t * 'a option * 'a t
        val find : key -> 'a t -> 'a
+        val find_opt : key -> 'a t -> 'a option
+        val find_first : (key -> bool) -> 'a t -> key * 'a
+        val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+        val find_last : (key -> bool) -> 'a t -> key * 'a
+        val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
        val map : ('a -> 'b) -> 'a t -> 'b t
        val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
        val to_seq : 'a t -> (key * 'a) sequence
diff --git a/api/type_SequenceLabels.Set.Adapt.html b/api/type_SequenceLabels.Set.Adapt.html index f1035d2..9e89d3c 100644 --- a/api/type_SequenceLabels.Set.Adapt.html +++ b/api/type_SequenceLabels.Set.Adapt.html @@ -38,10 +38,18 @@     val cardinal : t -> int
    val elements : t -> elt list
    val min_elt : t -> elt
+    val min_elt_opt : t -> elt option
    val max_elt : t -> elt
+    val max_elt_opt : t -> elt option
    val choose : t -> elt
+    val choose_opt : t -> elt option
    val split : elt -> t -> t * bool * t
    val find : elt -> t -> elt
+    val find_opt : elt -> t -> elt option
+    val find_first : (elt -> bool) -> t -> elt
+    val find_first_opt : (elt -> bool) -> t -> elt option
+    val find_last : (elt -> bool) -> t -> elt
+    val find_last_opt : (elt -> bool) -> t -> elt option
    val of_seq : elt sequence -> t
    val to_seq : t -> elt sequence
    val to_list : t -> elt list
diff --git a/api/type_SequenceLabels.Set.Make.html b/api/type_SequenceLabels.Set.Make.html index d96cefc..c4ae436 100644 --- a/api/type_SequenceLabels.Set.Make.html +++ b/api/type_SequenceLabels.Set.Make.html @@ -38,10 +38,18 @@     val cardinal : t -> int
    val elements : t -> elt list
    val min_elt : t -> elt
+    val min_elt_opt : t -> elt option
    val max_elt : t -> elt
+    val max_elt_opt : t -> elt option
    val choose : t -> elt
+    val choose_opt : t -> elt option
    val split : elt -> t -> t * bool * t
    val find : elt -> t -> elt
+    val find_opt : elt -> t -> elt option
+    val find_first : (elt -> bool) -> t -> elt
+    val find_first_opt : (elt -> bool) -> t -> elt option
+    val find_last : (elt -> bool) -> t -> elt
+    val find_last_opt : (elt -> bool) -> t -> elt option
    val of_seq : elt sequence -> t
    val to_seq : t -> elt sequence
    val to_list : t -> elt list
diff --git a/api/type_SequenceLabels.Set.S.html b/api/type_SequenceLabels.Set.S.html index 6cee1dd..d429e01 100644 --- a/api/type_SequenceLabels.Set.S.html +++ b/api/type_SequenceLabels.Set.S.html @@ -37,10 +37,18 @@   val cardinal : t -> int
  val elements : t -> elt list
  val min_elt : t -> elt
+  val min_elt_opt : t -> elt option
  val max_elt : t -> elt
+  val max_elt_opt : t -> elt option
  val choose : t -> elt
+  val choose_opt : t -> elt option
  val split : elt -> t -> t * bool * t
  val find : elt -> t -> elt
+  val find_opt : elt -> t -> elt option
+  val find_first : (elt -> bool) -> t -> elt
+  val find_first_opt : (elt -> bool) -> t -> elt option
+  val find_last : (elt -> bool) -> t -> elt
+  val find_last_opt : (elt -> bool) -> t -> elt option
  val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
  val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
  val to_list : SequenceLabels.t -> elt list
diff --git a/api/type_SequenceLabels.Set.html b/api/type_SequenceLabels.Set.html index eea38f2..142d356 100644 --- a/api/type_SequenceLabels.Set.html +++ b/api/type_SequenceLabels.Set.html @@ -39,10 +39,18 @@       val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
+      val min_elt_opt : t -> elt option
      val max_elt : t -> elt
+      val max_elt_opt : t -> elt option
      val choose : t -> elt
+      val choose_opt : t -> elt option
      val split : elt -> t -> t * bool * t
      val find : elt -> t -> elt
+      val find_opt : elt -> t -> elt option
+      val find_first : (elt -> bool) -> t -> elt
+      val find_first_opt : (elt -> bool) -> t -> elt option
+      val find_last : (elt -> bool) -> t -> elt
+      val find_last_opt : (elt -> bool) -> t -> elt option
      val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
      val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
      val to_list : SequenceLabels.t -> elt list
@@ -75,10 +83,18 @@         val cardinal : t -> int
        val elements : t -> elt list
        val min_elt : t -> elt
+        val min_elt_opt : t -> elt option
        val max_elt : t -> elt
+        val max_elt_opt : t -> elt option
        val choose : t -> elt
+        val choose_opt : t -> elt option
        val split : elt -> t -> t * bool * t
        val find : elt -> t -> elt
+        val find_opt : elt -> t -> elt option
+        val find_first : (elt -> bool) -> t -> elt
+        val find_first_opt : (elt -> bool) -> t -> elt option
+        val find_last : (elt -> bool) -> t -> elt
+        val find_last_opt : (elt -> bool) -> t -> elt option
        val of_seq : elt sequence -> t
        val to_seq : t -> elt sequence
        val to_list : t -> elt list
@@ -111,10 +127,18 @@         val cardinal : t -> int
        val elements : t -> elt list
        val min_elt : t -> elt
+        val min_elt_opt : t -> elt option
        val max_elt : t -> elt
+        val max_elt_opt : t -> elt option
        val choose : t -> elt
+        val choose_opt : t -> elt option
        val split : elt -> t -> t * bool * t
        val find : elt -> t -> elt
+        val find_opt : elt -> t -> elt option
+        val find_first : (elt -> bool) -> t -> elt
+        val find_first_opt : (elt -> bool) -> t -> elt option
+        val find_last : (elt -> bool) -> t -> elt
+        val find_last_opt : (elt -> bool) -> t -> elt option
        val of_seq : elt sequence -> t
        val to_seq : t -> elt sequence
        val to_list : t -> elt list
diff --git a/api/type_SequenceLabels.html b/api/type_SequenceLabels.html index 4dd957a..1d4e424 100644 --- a/api/type_SequenceLabels.html +++ b/api/type_SequenceLabels.html @@ -16,6 +16,8 @@   type 'a t = ('a -> unit) -> unit
  type 'a sequence = 'a SequenceLabels.t
  type ('a, 'b) t2 = ('a -> 'b -> unit) -> unit
+  type 'a equal = 'a -> 'a -> bool
+  type 'a hash = 'a -> int
  val from_iter : (('a -> unit) -> unit) -> 'a SequenceLabels.t
  val from_fun : (unit -> 'a option) -> 'a SequenceLabels.t
  val empty : 'a SequenceLabels.t
@@ -49,8 +51,11 @@   val for_all : f:('a -> bool) -> 'a SequenceLabels.t -> bool
  val exists : f:('a -> bool) -> 'a SequenceLabels.t -> bool
  val mem : ?eq:('a -> 'a -> bool) -> x:'a -> 'a SequenceLabels.t -> bool
-  val find : f:('a -> 'b option) -> 'a SequenceLabels.t -> 'b option
+  val find : ('a -> 'b option) -> 'a SequenceLabels.t -> 'b option
+  val find_map : f:('a -> 'b option) -> 'a SequenceLabels.t -> 'b option
  val findi : f:(int -> 'a -> 'b option) -> 'a SequenceLabels.t -> 'b option
+  val find_mapi :
+    f:(int -> 'a -> 'b option) -> 'a SequenceLabels.t -> 'b option
  val find_pred : f:('a -> bool) -> 'a SequenceLabels.t -> 'a option
  val find_pred_exn : f:('a -> bool) -> 'a SequenceLabels.t -> 'a
  val length : 'a SequenceLabels.t -> int
@@ -58,6 +63,7 @@   val filter : f:('a -> bool) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
  val append :
    'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+  val append_l : 'a SequenceLabels.t list -> 'a SequenceLabels.t
  val concat : 'a SequenceLabels.t SequenceLabels.t -> 'a SequenceLabels.t
  val flatten : 'a SequenceLabels.t SequenceLabels.t -> 'a SequenceLabels.t
  val flat_map :
@@ -67,6 +73,11 @@     f:('a -> 'b list) -> 'a SequenceLabels.t -> 'b SequenceLabels.t
  val filter_map :
    f:('a -> 'b option) -> 'a SequenceLabels.t -> 'b SequenceLabels.t
+  val filter_mapi :
+    f:(int -> 'a -> 'b option) -> 'a SequenceLabels.t -> 'b SequenceLabels.t
+  val seq_list : 'a SequenceLabels.t list -> 'a list SequenceLabels.t
+  val seq_list_map :
+    f:('a -> 'b SequenceLabels.t) -> 'a list -> 'b list SequenceLabels.t
  val intersperse : x:'a -> 'a SequenceLabels.t -> 'a SequenceLabels.t
  val persistent : 'a SequenceLabels.t -> 'a SequenceLabels.t
  val persistent_lazy : 'a SequenceLabels.t -> 'a SequenceLabels.t
@@ -95,11 +106,51 @@   val join :
    join_row:('a -> 'b -> 'c option) ->
    'a SequenceLabels.t -> 'b SequenceLabels.t -> 'c SequenceLabels.t
+  val join_by :
+    ?eq:'key SequenceLabels.equal ->
+    ?hash:'key SequenceLabels.hash ->
+    ('a -> 'key) ->
+    ('b -> 'key) ->
+    merge:('key -> 'a -> 'b -> 'c option) ->
+    'a SequenceLabels.t -> 'b SequenceLabels.t -> 'c SequenceLabels.t
+  val join_all_by :
+    ?eq:'key SequenceLabels.equal ->
+    ?hash:'key SequenceLabels.hash ->
+    ('a -> 'key) ->
+    ('b -> 'key) ->
+    merge:('key -> 'a list -> 'b list -> 'c option) ->
+    'a SequenceLabels.t -> 'b SequenceLabels.t -> 'c SequenceLabels.t
+  val group_join_by :
+    ?eq:'a SequenceLabels.equal ->
+    ?hash:'a SequenceLabels.hash ->
+    ('b -> 'a) ->
+    'a SequenceLabels.t ->
+    'b SequenceLabels.t -> ('a * 'b list) SequenceLabels.t
+  val inter :
+    ?eq:'a SequenceLabels.equal ->
+    ?hash:'a SequenceLabels.hash ->
+    'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+  val union :
+    ?eq:'a SequenceLabels.equal ->
+    ?hash:'a SequenceLabels.hash ->
+    'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+  val diff :
+    ?eq:'a SequenceLabels.equal ->
+    ?hash:'a SequenceLabels.hash ->
+    'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+  val subset :
+    ?eq:'a SequenceLabels.equal ->
+    ?hash:'a SequenceLabels.hash ->
+    'a SequenceLabels.t -> 'a SequenceLabels.t -> bool
  val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a SequenceLabels.t
  val scan :
    ('b -> 'a -> 'b) -> 'b -> 'a SequenceLabels.t -> 'b SequenceLabels.t
  val max : ?lt:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a option
+  val max_exn : ?lt:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a
  val min : ?lt:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a option
+  val min_exn : ?lt:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a
+  val sum : int SequenceLabels.t -> int
+  val sumf : float SequenceLabels.t -> float
  val head : 'a SequenceLabels.t -> 'a option
  val head_exn : 'a SequenceLabels.t -> 'a
  val take : int -> 'a SequenceLabels.t -> 'a SequenceLabels.t
@@ -132,6 +183,7 @@   val of_list : 'a list -> 'a SequenceLabels.t
  val on_list :
    ('a SequenceLabels.t -> 'b SequenceLabels.t) -> 'a list -> 'b list
+  val pair_with_idx : 'a SequenceLabels.t -> (int * 'a) SequenceLabels.t
  val to_opt : 'a SequenceLabels.t -> 'a option
  val to_array : 'a SequenceLabels.t -> 'a array
  val of_array : 'a array -> 'a SequenceLabels.t
@@ -205,10 +257,18 @@           val cardinal : t -> int
          val elements : t -> elt list
          val min_elt : t -> elt
+          val min_elt_opt : t -> elt option
          val max_elt : t -> elt
+          val max_elt_opt : t -> elt option
          val choose : t -> elt
+          val choose_opt : t -> elt option
          val split : elt -> t -> t * bool * t
          val find : elt -> t -> elt
+          val find_opt : elt -> t -> elt option
+          val find_first : (elt -> bool) -> t -> elt
+          val find_first_opt : (elt -> bool) -> t -> elt option
+          val find_last : (elt -> bool) -> t -> elt
+          val find_last_opt : (elt -> bool) -> t -> elt option
          val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
          val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
          val to_list : SequenceLabels.t -> elt list
@@ -241,10 +301,18 @@             val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
+            val min_elt_opt : t -> elt option
            val max_elt : t -> elt
+            val max_elt_opt : t -> elt option
            val choose : t -> elt
+            val choose_opt : t -> elt option
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
+            val find_opt : elt -> t -> elt option
+            val find_first : (elt -> bool) -> t -> elt
+            val find_first_opt : (elt -> bool) -> t -> elt option
+            val find_last : (elt -> bool) -> t -> elt
+            val find_last_opt : (elt -> bool) -> t -> elt option
            val of_seq : elt sequence -> t
            val to_seq : t -> elt sequence
            val to_list : t -> elt list
@@ -277,10 +345,18 @@             val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
+            val min_elt_opt : t -> elt option
            val max_elt : t -> elt
+            val max_elt_opt : t -> elt option
            val choose : t -> elt
+            val choose_opt : t -> elt option
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
+            val find_opt : elt -> t -> elt option
+            val find_first : (elt -> bool) -> t -> elt
+            val find_first_opt : (elt -> bool) -> t -> elt option
+            val find_last : (elt -> bool) -> t -> elt
+            val find_last_opt : (elt -> bool) -> t -> elt option
            val of_seq : elt sequence -> t
            val to_seq : t -> elt sequence
            val to_list : t -> elt list
@@ -314,10 +390,18 @@           val cardinal : 'a t -> int
          val bindings : 'a t -> (key * 'a) list
          val min_binding : 'a t -> key * 'a
+          val min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
+          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
+          val choose_opt : 'a t -> (key * 'a) option
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
+          val find_opt : key -> 'a t -> 'a option
+          val find_first : (key -> bool) -> 'a t -> key * 'a
+          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+          val find_last : (key -> bool) -> 'a t -> key * 'a
+          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val map : ('a -> 'b) -> 'a t -> 'b t
          val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
          val to_seq :
@@ -356,10 +440,18 @@             val cardinal : 'a t -> int
            val bindings : 'a t -> (key * 'a) list
            val min_binding : 'a t -> key * 'a
+            val min_binding_opt : 'a t -> (key * 'a) option
            val max_binding : 'a t -> key * 'a
+            val max_binding_opt : 'a t -> (key * 'a) option
            val choose : 'a t -> key * 'a
+            val choose_opt : 'a t -> (key * 'a) option
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
+            val find_opt : key -> 'a t -> 'a option
+            val find_first : (key -> bool) -> 'a t -> key * 'a
+            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+            val find_last : (key -> bool) -> 'a t -> key * 'a
+            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val map : ('a -> 'b) -> 'a t -> 'b t
            val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
            val to_seq : 'a t -> (key * 'a) sequence
@@ -396,10 +488,18 @@             val cardinal : 'a t -> int
            val bindings : 'a t -> (key * 'a) list
            val min_binding : 'a t -> key * 'a
+            val min_binding_opt : 'a t -> (key * 'a) option
            val max_binding : 'a t -> key * 'a
+            val max_binding_opt : 'a t -> (key * 'a) option
            val choose : 'a t -> key * 'a
+            val choose_opt : 'a t -> (key * 'a) option
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
+            val find_opt : key -> 'a t -> 'a option
+            val find_first : (key -> bool) -> 'a t -> key * 'a
+            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
+            val find_last : (key -> bool) -> 'a t -> key * 'a
+            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val map : ('a -> 'b) -> 'a t -> 'b t
            val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
            val to_seq : 'a t -> (key * 'a) sequence