module Sequential:sig..end
The sequential implementation (to be used as a reference)
val compute : worker:('a -> 'b) ->
master:('a * 'c -> 'b -> ('a * 'c) list) -> ('a * 'c) list -> unitmaster f handle l applies function f to each first-component
of elements in l; for each such computation, both the list element
and the result are passed to handle, which returns a list of
new elements to be processed (in an identical manner).
The computation stops when there is no more element to be processed.
The following functions are provided for convenience; they can be derived from the generic function above.
val map : f:('a -> 'b) -> 'a list -> 'b listsame result as List.map
val map_local_fold : f:('a -> 'b) -> fold:('c -> 'b -> 'c) -> 'c -> 'a list -> 'cmap_local_fold f fold acc l computes
fold ... (fold (fold acc (f x1)) (f x2)) ... (f xn)
for some permutation x1,x2,...,xn of l
val map_remote_fold : f:('a -> 'b) -> fold:('c -> 'b -> 'c) -> 'c -> 'a list -> 'csame specification as above
val map_fold_ac : f:('a -> 'b) -> fold:('b -> 'b -> 'b) -> 'b -> 'a list -> 'bsame specification, assuming fold is an associative and
commutative operation; the third argument should be a
neutral element for fold
val map_fold_a : f:('a -> 'b) -> fold:('b -> 'b -> 'b) -> 'b -> 'a list -> 'bmap_fold_a f fold acc [x1;...xn] computes
fold ... (fold (fold acc (f x1)) (f x2)) ... (f xn)
assuming fold is an associative
operation with neutral element acc