1Seq(3) OCaml library Seq(3)
2
6 Seq - Sequences.
7
9 Module Seq
10
12 Module Seq
13 : sig end
14 Sequences.
17 A sequence of type 'a Seq.t can be thought of as a delayed list, that
19 is, a list whose elements are computed only when they are demanded by a
20 consumer. This allows sequences to be produced and transformed lazily
21 (one element at a time) rather than eagerly (all elements at once).
22 This also allows constructing conceptually infinite sequences.
23 The type 'a Seq.t is defined as a synonym for unit -> 'a Seq.node .
25 This is a function type: therefore, it is opaque. The consumer can
26 query a sequence in order to request the next element (if there is
27 one), but cannot otherwise inspect the sequence in any way.
28 Because it is opaque, the type 'a Seq.t does not reveal whether a se‐
30 quence is:
31 -persistent, which means that the sequence can be used as many times as
33 desired, producing the same elements every time, just like an immutable
34 list; or
35 -ephemeral, which means that the sequence is not persistent. Querying
37 an ephemeral sequence might have an observable side effect, such as in‐
38 crementing a mutable counter. As a common special case, an ephemeral
39 sequence can be affine, which means that it must be queried at most
40 once.
41 It also does not reveal whether the elements of the sequence are:
43 -pre-computed and stored in memory, which means that querying the se‐
46 quence is cheap;
47 -computed when first demanded and then stored in memory, which means
49 that querying the sequence once can be expensive, but querying the same
50 sequence again is cheap; or
51 -re-computed every time they are demanded, which may or may not be
53 cheap.
54 It is up to the programmer to keep these distinctions in mind so as to
56 understand the time and space requirements of sequences.
57 For the sake of simplicity, most of the documentation that follows is
59 written under the implicit assumption that the sequences at hand are
60 persistent. We normally do not point out when or how many times each
61 function is invoked, because that would be too verbose. For instance,
62 in the description of map , we write: "if xs is the sequence x0; x1;
63 ... then map f xs is the sequence f x0; f x1; ... ". If we wished to
64 be more explicit, we could point out that the transformation takes
65 place on demand: that is, the elements of map f xs are computed only
66 when they are demanded. In other words, the definition let ys = map f
67 xs terminates immediately and does not invoke f . The function call f
68 x0 takes place only when the first element of ys is demanded, via the
69 function call ys() . Furthermore, calling ys() twice causes f x0 to be
70 called twice as well. If one wishes for f to be applied at most once to
71 each element of xs , even in scenarios where ys is queried more than
72 once, then one should use let ys = memoize (map f xs) .
73 As a general rule, the functions that build sequences, such as map ,
75 filter , scan , take , etc., produce sequences whose elements are com‐
76 puted only on demand. The functions that eagerly consume sequences,
77 such as is_empty , find , length , iter , fold_left , etc., are the
78 functions that force computation to take place.
79 When possible, we recommend using sequences rather than dispensers
81 (functions of type unit -> 'a option that produce elements upon de‐
82 mand). Whereas sequences can be persistent or ephemeral, dispensers are
83 always ephemeral, and are typically more difficult to work with than
84 sequences. Two conversion functions, Seq.to_dispenser and Seq.of_dis‐
85 penser , are provided.
86 Since 4.07
89 type 'a t = unit -> 'a node
95 A sequence xs of type 'a t is a delayed list of elements of type 'a .
98 Such a sequence is queried by performing a function application xs() .
99 This function application returns a node, allowing the caller to deter‐
100 mine whether the sequence is empty or nonempty, and in the latter case,
101 to obtain its head and tail.
102 type 'a node =
105 | Nil
106 | Cons of 'a * 'a t
107 A node is either Nil , which means that the sequence is empty, or Cons
110 (x, xs) , which means that x is the first element of the sequence and
111 that xs is the remainder of the sequence.
112 Consuming sequences
117 The functions in this section consume their argument, a sequence, ei‐
118 ther partially or completely:
119 - is_empty and uncons consume the sequence down to depth 1. That is,
121 they demand the first argument of the sequence, if there is one.
122 - iter , fold_left , length , etc., consume the sequence all the way to
124 its end. They terminate only if the sequence is finite.
125 - for_all , exists , find , etc. consume the sequence down to a certain
127 depth, which is a priori unpredictable.
128 Similarly, among the functions that consume two sequences, one can dis‐
130 tinguish two groups:
131 - iter2 and fold_left2 consume both sequences all the way to the end,
133 provided the sequences have the same length.
134 - for_all2 , exists2 , equal , compare consume the sequences down to a
136 certain depth, which is a priori unpredictable.
137 The functions that consume two sequences can be applied to two se‐
139 quences of distinct lengths: in that case, the excess elements in the
140 longer sequence are ignored. (It may be the case that one excess ele‐
141 ment is demanded, even though this element is not used.)
142 None of the functions in this section is lazy. These functions are con‐
144 sumers: they force some computation to take place.
145 val is_empty : 'a t -> bool
147 is_empty xs determines whether the sequence xs is empty.
150 It is recommended that the sequence xs be persistent. Indeed, is_empty
152 xs demands the head of the sequence xs , so, if xs is ephemeral, it may
153 be the case that xs cannot be used any more after this call has taken
154 place.
155 Since 4.14
158 val uncons : 'a t -> ('a * 'a t) option
162 If xs is empty, then uncons xs is None .
164 If xs is nonempty, then uncons xs is Some (x, ys) where x is the head
166 of the sequence and ys its tail.
167 Since 4.14
170 val length : 'a t -> int
174 length xs is the length of the sequence xs .
177 The sequence xs must be finite.
179 Since 4.14
182 val iter : ('a -> unit) -> 'a t -> unit
186 iter f xs invokes f x successively for every element x of the sequence
189 xs , from left to right.
190 It terminates only if the sequence xs is finite.
192 val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
196 fold_left f _ xs invokes f _ x successively for every element x of the
199 sequence xs , from left to right.
200 An accumulator of type 'a is threaded through the calls to f .
202 It terminates only if the sequence xs is finite.
204 val iteri : (int -> 'a -> unit) -> 'a t -> unit
208 iteri f xs invokes f i x successively for every element x located at
211 index i in the sequence xs .
212 It terminates only if the sequence xs is finite.
214 iteri f xs is equivalent to iter (fun (i, x) -> f i x) (zip (ints 0)
217 xs) .
218 Since 4.14
221 val fold_lefti : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'b
225 fold_lefti f _ xs invokes f _ i x successively for every element x lo‐
228 cated at index i of the sequence xs .
229 An accumulator of type 'b is threaded through the calls to f .
231 It terminates only if the sequence xs is finite.
233 fold_lefti f accu xs is equivalent to fold_left (fun accu (i, x) -> f
236 accu i x) accu (zip (ints 0) xs) .
237 Since 4.14
240 val for_all : ('a -> bool) -> 'a t -> bool
244 for_all p xs determines whether all elements x of the sequence xs sat‐
247 isfy p x .
248 The sequence xs must be finite.
250 Since 4.14
253 val exists : ('a -> bool) -> 'a t -> bool
257 exists xs p determines whether at least one element x of the sequence
260 xs satisfies p x .
261 The sequence xs must be finite.
263 Since 4.14
266 val find : ('a -> bool) -> 'a t -> 'a option
270 find p xs returns Some x , where x is the first element of the sequence
273 xs that satisfies p x , if there is such an element.
274 It returns None if there is no such element.
276 The sequence xs must be finite.
278 Since 4.14
281 val find_map : ('a -> 'b option) -> 'a t -> 'b option
285 find_map f xs returns Some y , where x is the first element of the se‐
288 quence xs such that f x = Some _ , if there is such an element, and
289 where y is defined by f x = Some y .
290 It returns None if there is no such element.
292 The sequence xs must be finite.
294 Since 4.14
297 val iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit
301 iter2 f xs ys invokes f x y successively for every pair (x, y) of ele‐
304 ments drawn synchronously from the sequences xs and ys .
305 If the sequences xs and ys have different lengths, then iteration stops
307 as soon as one sequence is exhausted; the excess elements in the other
308 sequence are ignored.
309 Iteration terminates only if at least one of the sequences xs and ys is
311 finite.
312 iter2 f xs ys is equivalent to iter (fun (x, y) -> f x y) (zip xs ys) .
315 Since 4.14
318 val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b t -> 'c t -> 'a
322 fold_left2 f _ xs ys invokes f _ x y successively for every pair (x, y)
325 of elements drawn synchronously from the sequences xs and ys .
326 An accumulator of type 'a is threaded through the calls to f .
328 If the sequences xs and ys have different lengths, then iteration stops
330 as soon as one sequence is exhausted; the excess elements in the other
331 sequence are ignored.
332 Iteration terminates only if at least one of the sequences xs and ys is
334 finite.
335 fold_left2 f accu xs ys is equivalent to fold_left (fun accu (x, y) ->
338 f accu x y) (zip xs ys) .
339 Since 4.14
342 val for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
346 for_all2 p xs ys determines whether all pairs (x, y) of elements drawn
349 synchronously from the sequences xs and ys satisfy p x y .
350 If the sequences xs and ys have different lengths, then iteration stops
352 as soon as one sequence is exhausted; the excess elements in the other
353 sequence are ignored. In particular, if xs or ys is empty, then
354 for_all2 p xs ys is true. This is where for_all2 and equal differ:
355 equal eq xs ys can be true only if xs and ys have the same length.
356 At least one of the sequences xs and ys must be finite.
358 for_all2 p xs ys is equivalent to for_all (fun b -> b) (map2 p xs ys) .
361 Since 4.14
364 val exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
368 exists2 p xs ys determines whether some pair (x, y) of elements drawn
371 synchronously from the sequences xs and ys satisfies p x y .
372 If the sequences xs and ys have different lengths, then iteration must
374 stop as soon as one sequence is exhausted; the excess elements in the
375 other sequence are ignored.
376 At least one of the sequences xs and ys must be finite.
378 exists2 p xs ys is equivalent to exists (fun b -> b) (map2 p xs ys) .
381 Since 4.14
384 val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
388 Provided the function eq defines an equality on elements, equal eq xs
390 ys determines whether the sequences xs and ys are pointwise equal.
391 At least one of the sequences xs and ys must be finite.
393 Since 4.14
396 val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
400 Provided the function cmp defines a preorder on elements, compare cmp
402 xs ys compares the sequences xs and ys according to the lexicographic
403 preorder.
404 For more details on comparison functions, see Array.sort .
406 At least one of the sequences xs and ys must be finite.
408 Since 4.14
411 Constructing sequences
416 The functions in this section are lazy: that is, they return sequences
417 whose elements are computed only when demanded.
418 val empty : 'a t
420 empty is the empty sequence. It has no elements. Its length is 0.
423 val return : 'a -> 'a t
427 return x is the sequence whose sole element is x . Its length is 1.
430 val cons : 'a -> 'a t -> 'a t
434 cons x xs is the sequence that begins with the element x , followed
437 with the sequence xs .
438 Writing cons (f()) xs causes the function call f() to take place imme‐
440 diately. For this call to be delayed until the sequence is queried, one
441 must instead write (fun () -> Cons(f(), xs)) .
442 Since 4.11
445 val init : int -> (int -> 'a) -> 'a t
449 init n f is the sequence f 0; f 1; ...; f (n-1) .
452 n must be nonnegative.
455 If desired, the infinite sequence f 0; f 1; ... can be defined as map
457 f (ints 0) .
458 Since 4.14
461 Raises Invalid_argument if n is negative.
464 val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t
468 unfold constructs a sequence out of a step function and an initial
471 state.
472 If f u is None then unfold f u is the empty sequence. If f u is Some
474 (x, u') then unfold f u is the nonempty sequence cons x (unfold f u') .
475 For example, unfold (function [] -> None | h :: t -> Some (h, t)) l is
477 equivalent to List.to_seq l .
478 Since 4.11
481 val repeat : 'a -> 'a t
485 repeat x is the infinite sequence where the element x is repeated in‐
488 definitely.
489 repeat x is equivalent to cycle (return x) .
492 Since 4.14
495 val forever : (unit -> 'a) -> 'a t
499 forever f is an infinite sequence where every element is produced (on
502 demand) by the function call f() .
503 For instance, forever Random.bool is an infinite sequence of random
505 bits.
506 forever f is equivalent to map f (repeat ()) .
509 Since 4.14
512 val cycle : 'a t -> 'a t
516 cycle xs is the infinite sequence that consists of an infinite number
519 of repetitions of the sequence xs .
520 If xs is an empty sequence, then cycle xs is empty as well.
522 Consuming (a prefix of) the sequence cycle xs once can cause the se‐
524 quence xs to be consumed more than once. Therefore, xs must be persis‐
525 tent.
526 Since 4.14
529 val iterate : ('a -> 'a) -> 'a -> 'a t
533 iterate f x is the infinite sequence whose elements are x , f x , f (f
536 x) , and so on.
537 In other words, it is the orbit of the function f , starting at x .
539 Since 4.14
542 Transforming sequences
547 The functions in this section are lazy: that is, they return sequences
548 whose elements are computed only when demanded.
549 val map : ('a -> 'b) -> 'a t -> 'b t
551 map f xs is the image of the sequence xs through the transformation f .
554 If xs is the sequence x0; x1; ... then map f xs is the sequence f x0;
556 f x1; ... .
557 val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t
561 mapi is analogous to map , but applies the function f to an index and
564 an element.
565 mapi f xs is equivalent to map2 f (ints 0) xs .
568 Since 4.14
571 val filter : ('a -> bool) -> 'a t -> 'a t
575 filter p xs is the sequence of the elements x of xs that satisfy p x .
578 In other words, filter p xs is the sequence xs , deprived of the ele‐
580 ments x such that p x is false.
581 val filter_map : ('a -> 'b option) -> 'a t -> 'b t
585 filter_map f xs is the sequence of the elements y such that f x = Some
588 y , where x ranges over xs .
589 filter_map f xs is equivalent to map Option.get (filter Option.is_some
592 (map f xs)) .
593 val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t
597 If xs is a sequence [x0; x1; x2; ...] , then scan f a0 xs is a se‐
599 quence of accumulators [a0; a1; a2; ...] where a1 is f a0 x0 , a2 is f
600 a1 x1 , and so on.
601 Thus, scan f a0 xs is conceptually related to fold_left f a0 xs . How‐
603 ever, instead of performing an eager iteration and immediately return‐
604 ing the final accumulator, it returns a sequence of accumulators.
605 For instance, scan (+) 0 transforms a sequence of integers into the se‐
607 quence of its partial sums.
608 If xs has length n then scan f a0 xs has length n+1 .
610 Since 4.14
613 val take : int -> 'a t -> 'a t
617 take n xs is the sequence of the first n elements of xs .
620 If xs has fewer than n elements, then take n xs is equivalent to xs .
622 n must be nonnegative.
625 Since 4.14
628 Raises Invalid_argument if n is negative.
631 val drop : int -> 'a t -> 'a t
635 drop n xs is the sequence xs , deprived of its first n elements.
638 If xs has fewer than n elements, then drop n xs is empty.
640 n must be nonnegative.
643 drop is lazy: the first n+1 elements of the sequence xs are demanded
646 only when the first element of drop n xs is demanded. For this reason,
647 drop 1 xs is not equivalent to tail xs , which queries xs immediately.
648 Since 4.14
651 Raises Invalid_argument if n is negative.
654 val take_while : ('a -> bool) -> 'a t -> 'a t
658 take_while p xs is the longest prefix of the sequence xs where every
661 element x satisfies p x .
662 Since 4.14
665 val drop_while : ('a -> bool) -> 'a t -> 'a t
669 drop_while p xs is the sequence xs , deprived of the prefix take_while
672 p xs .
673 Since 4.14
676 val group : ('a -> 'a -> bool) -> 'a t -> 'a t t
680 Provided the function eq defines an equality on elements, group eq xs
682 is the sequence of the maximal runs of adjacent duplicate elements of
683 the sequence xs .
684 Every element of group eq xs is a nonempty sequence of equal elements.
686 The concatenation concat (group eq xs) is equal to xs .
688 Consuming group eq xs , and consuming the sequences that it contains,
690 can cause xs to be consumed more than once. Therefore, xs must be per‐
691 sistent.
692 Since 4.14
695 val memoize : 'a t -> 'a t
699 The sequence memoize xs has the same elements as the sequence xs .
701 Regardless of whether xs is ephemeral or persistent, memoize xs is per‐
703 sistent: even if it is queried several times, xs is queried at most
704 once.
705 The construction of the sequence memoize xs internally relies on sus‐
707 pensions provided by the module Lazy . These suspensions are not
708 thread-safe. Therefore, the sequence memoize xs must not be queried by
709 multiple threads concurrently.
710 Since 4.14
713 exception Forced_twice
717 This exception is raised when a sequence returned by Seq.once (or a
720 suffix of it) is queried more than once.
721 Since 4.14
724 val once : 'a t -> 'a t
728 The sequence once xs has the same elements as the sequence xs .
730 Regardless of whether xs is ephemeral or persistent, once xs is an
732 ephemeral sequence: it can be queried at most once. If it (or a suffix
733 of it) is queried more than once, then the exception Forced_twice is
734 raised. This can be useful, while debugging or testing, to ensure that
735 a sequence is consumed at most once.
736 Since 4.14
739 Raises Forced_twice if once xs , or a suffix of it, is queried more
742 than once.
743 val transpose : 'a t t -> 'a t t
747 If xss is a matrix (a sequence of rows), then transpose xss is the se‐
749 quence of the columns of the matrix xss .
750 The rows of the matrix xss are not required to have the same length.
752 The matrix xss is not required to be finite (in either direction).
754 The matrix xss must be persistent.
756 Since 4.14
759 Combining sequences
764 val append : 'a t -> 'a t -> 'a t
765 append xs ys is the concatenation of the sequences xs and ys .
768 Its elements are the elements of xs , followed by the elements of ys .
770 Since 4.11
773 val concat : 'a t t -> 'a t
777 If xss is a sequence of sequences, then concat xss is its concatena‐
779 tion.
780 If xss is the sequence xs0; xs1; ... then concat xss is the sequence
782 xs0 @ xs1 @ ... .
783 Since 4.13
786 val flat_map : ('a -> 'b t) -> 'a t -> 'b t
790 flat_map f xs is equivalent to concat (map f xs) .
793 val concat_map : ('a -> 'b t) -> 'a t -> 'b t
797 concat_map f xs is equivalent to concat (map f xs) .
800 concat_map is an alias for flat_map .
803 Since 4.13
806 val zip : 'a t -> 'b t -> ('a * 'b) t
810 zip xs ys is the sequence of pairs (x, y) drawn synchronously from the
813 sequences xs and ys .
814 If the sequences xs and ys have different lengths, then the sequence
816 ends as soon as one sequence is exhausted; the excess elements in the
817 other sequence are ignored.
818 zip xs ys is equivalent to map2 (fun a b -> (a, b)) xs ys .
821 Since 4.14
824 val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
828 map2 f xs ys is the sequence of the elements f x y , where the pairs
831 (x, y) are drawn synchronously from the sequences xs and ys .
832 If the sequences xs and ys have different lengths, then the sequence
834 ends as soon as one sequence is exhausted; the excess elements in the
835 other sequence are ignored.
836 map2 f xs ys is equivalent to map (fun (x, y) -> f x y) (zip xs ys) .
839 Since 4.14
842 val interleave : 'a t -> 'a t -> 'a t
846 interleave xs ys is the sequence that begins with the first element of
849 xs , continues with the first element of ys , and so on.
850 When one of the sequences xs and ys is exhausted, interleave xs ys con‐
852 tinues with the rest of the other sequence.
853 Since 4.14
856 val sorted_merge : ('a -> 'a -> int) -> 'a t -> 'a t -> 'a t
860 If the sequences xs and ys are sorted according to the total preorder
862 cmp , then sorted_merge cmp xs ys is the sorted sequence obtained by
863 merging the sequences xs and ys .
864 For more details on comparison functions, see Array.sort .
866 Since 4.14
869 val product : 'a t -> 'b t -> ('a * 'b) t
873 product xs ys is the Cartesian product of the sequences xs and ys .
876 For every element x of xs and for every element y of ys , the pair (x,
878 y) appears once as an element of product xs ys .
879 The order in which the pairs appear is unspecified.
881 The sequences xs and ys are not required to be finite.
883 The sequences xs and ys must be persistent.
885 Since 4.14
888 val map_product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
892 The sequence map_product f xs ys is the image through f of the Carte‐
894 sian product of the sequences xs and ys .
895 For every element x of xs and for every element y of ys , the element f
897 x y appears once as an element of map_product f xs ys .
898 The order in which these elements appear is unspecified.
900 The sequences xs and ys are not required to be finite.
902 The sequences xs and ys must be persistent.
904 map_product f xs ys is equivalent to map (fun (x, y) -> f x y) (product
907 xs ys) .
908 Since 4.14
911 Splitting a sequence into two sequences
916 val unzip : ('a * 'b) t -> 'a t * 'b t
917 unzip transforms a sequence of pairs into a pair of sequences.
920 unzip xs is equivalent to (map fst xs, map snd xs) .
923 Querying either of the sequences returned by unzip xs causes xs to be
925 queried. Therefore, querying both of them causes xs to be queried
926 twice. Thus, xs must be persistent and cheap. If that is not the
927 case, use unzip (memoize xs) .
928 Since 4.14
931 val split : ('a * 'b) t -> 'a t * 'b t
935 split is an alias for unzip .
938 Since 4.14
941 val partition_map : ('a -> ('b, 'c) Either.t) -> 'a t -> 'b t * 'c t
945 partition_map f xs returns a pair of sequences (ys, zs) , where:
948 - ys is the sequence of the elements y such that f x = Left y , where x
951 ranges over xs ;
952 - zs is the sequence of the elements z such that f x = Right z , where
955 x ranges over xs .
956 partition_map f xs is equivalent to a pair of filter_map Ei‐
958 ther.find_left (map f xs) and filter_map Either.find_right (map f xs) .
959 Querying either of the sequences returned by partition_map f xs causes
961 xs to be queried. Therefore, querying both of them causes xs to be
962 queried twice. Thus, xs must be persistent and cheap. If that is not
963 the case, use partition_map f (memoize xs) .
964 Since 4.14
967 val partition : ('a -> bool) -> 'a t -> 'a t * 'a t
971 partition p xs returns a pair of the subsequence of the elements of xs
974 that satisfy p and the subsequence of the elements of xs that do not
975 satisfy p .
976 partition p xs is equivalent to filter p xs, filter (fun x -> not (p
979 x)) xs .
980 Consuming both of the sequences returned by partition p xs causes xs to
982 be consumed twice and causes the function f to be applied twice to each
983 element of the list. Therefore, f should be pure and cheap. Further‐
984 more, xs should be persistent and cheap. If that is not the case, use
985 partition p (memoize xs) .
986 Since 4.14
989 Converting between sequences and dispensers
994 A dispenser is a representation of a sequence as a function of type
995 unit -> 'a option . Every time this function is invoked, it returns the
996 next element of the sequence. When there are no more elements, it re‐
997 turns None . A dispenser has mutable internal state, therefore is
998 ephemeral: the sequence that it represents can be consumed at most
999 once.
1000 val of_dispenser : (unit -> 'a option) -> 'a t
1002 of_dispenser it is the sequence of the elements produced by the dis‐
1005 penser it . It is an ephemeral sequence: it can be consumed at most
1006 once. If a persistent sequence is needed, use memoize (of_dispenser it)
1007 .
1008 Since 4.14
1011 val to_dispenser : 'a t -> unit -> 'a option
1015 to_dispenser xs is a fresh dispenser on the sequence xs .
1018 This dispenser has mutable internal state, which is not protected by a
1020 lock; so, it must not be used by several threads concurrently.
1021 Since 4.14
1024 Sequences of integers
1029 val ints : int -> int t
1030 ints i is the infinite sequence of the integers beginning at i and
1033 counting up.
1034 Since 4.14
1037OCamldoc 2023-07-20 Seq(3)