Module type Parallel_sequence.S

type 'a t

'a t represents a finite sequence of independent computations that produce an 'a. These computations are evaluated in parallel upon collecting the sequence into a strict data structure. Parallel sequences are distinguished from normal sequences by supporting the split operation, which divides a sequence into two parts that may be collected in parallel.

val empty : 'a t @@ portable

The empty sequence.

val globalize : 'a t @ local -> 'a t @@ portable

globalize seq copies a local sequence to the heap.

val range : ?stride:Base.int -> ?start:[ `inclusive | `exclusive ] -> ?stop:[ `inclusive | `exclusive ] -> Base.int -> Base.int -> Base.int t @ local @@ portable

range ?stride ?start ?stop start_i stop_i is the sequence of integers from start_i to stop_i, stepping by stride. If stride < 0 then we need start_i > stop_i for the result to be nonempty (or start_i >= stop_i in the case where both bounds are inclusive).

val init : Base.int -> f:(Parallel_kernel.t @ local -> (Base.int -> 'a) @ local) @ portable -> 'a t @ local @@ portable

init n ~f is a sequence containing f _ i for each i in 0..n-1.

val of_iarray : 'a. 'a Base.iarray -> 'a t @ local @@ portable

of_iarray i is a sequence containing the contents of the iarray i. This sequence has a known length and may be split in constant time.

val append : 'a t @ local -> ('a t @ local -> 'a t @ local) @ local @@ portable

append s0 s1 returns a sequence containing the elements of s0 and then the elements of s1.

val product_left : 'a. 'a t @ local -> ('b t @ local -> ('a * 'b) t @ local) @ local @@ portable

product_left seq0 seq1 joins an 'a sequence and a 'b sequence into an ('a * 'b) sequence by pairing each element of seq0 with a copy of seq1.

val product_right : 'b. 'a t @ local -> ('b t @ local -> ('a * 'b) t @ local) @ local @@ portable

product_right seq0 seq1 joins an 'a sequence and a 'b sequence into an ('a * 'b) sequence by pairing each element of seq1 with a copy of seq0.

val map : 'a t @ local -> (f:(Parallel_kernel.t @ local -> ('a -> 'b) @ local) @ portable -> 'b t @ local) @ local @@ portable

map seq ~f converts an 'a sequence to a 'b sequence by applying f to each element of seq.

val iter : Parallel_kernel.t @ local -> ('a t @ local -> (f:(Parallel_kernel.t @ local -> ('a -> Base.unit) @ local) @ shareable -> Base.unit) @ local) @ local @@ portable

iter parallel seq ~f applies f to each element of seq in parallel. The order in which f is applied is unspecified and potentially non-deterministic.

val fold : Parallel_kernel.t @ local -> ('a t @ local -> (init:(Base.unit -> 'acc) @ portable -> (f: (Parallel_kernel.t @ local -> ('acc -> ('a -> 'acc) @ local) @ local) @ shareable -> (combine: (Parallel_kernel.t @ local -> ('acc -> ('acc -> 'acc) @ local) @ local) @ shareable -> 'acc) @ local) @ local) @ local) @ local @@ portable

fold parallel seq ~f ~init ~combine folds combine over map seq ~f in parallel. combine and init must form a monoid over 'acc: combine must be associative and init () must be a neutral element. The order in which f and combine are applied is unspecified and potentially non-deterministic.

val reduce : Parallel_kernel.t @ local -> ('a t @ local -> (f: (Parallel_kernel.t @ local -> ('a -> ('a -> 'a) @ local) @ local) @ shareable -> 'a Base.option) @ local) @ local @@ portable

reduce parallel seq ~f reduces seq using f in parallel. f must be associative. If the sequence is empty, reduce returns None. The order in which f is applied is unspecified and potentially non-deterministic.

val find : Parallel_kernel.t @ local -> ('a t @ local -> (f:(Parallel_kernel.t @ local -> ('a -> Base.bool) @ local) @ shareable -> 'a Base.option) @ local) @ local @@ portable

find parallel seq ~f returns the first element of seq for which f returns true, if it exists. f will always be applied to every element of seq. The order in which f is applied is unspecified and potentially non-deterministic.

val to_list : Parallel_kernel.t @ local -> ('a t @ local -> 'a Base.list) @ local @@ portable

to_list seq collects a sequence into a list by evaluating each element in parallel. Requires iterating the sequence sequentially.

val to_iarray : Parallel_kernel.t @ local -> ('a t @ local -> 'a Base.iarray) @ local @@ portable

to_iarray seq collects a sequence into an iarray by evaluating each element in parallel. If the sequence has a known length, does not require iterating the sequence sequentially.