# Module Functory.Sequential

module Sequential: sig .. end

The sequential implementation (to be used as a reference)

### Generic API

val compute : worker:('a -> 'b) ->
master:('a * 'c -> 'b -> ('a * 'c) list) -> ('a * 'c) list -> unit

master 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.

### Derived API

The following functions are provided for convenience; they can be derived from the generic function above.

val map : f:('a -> 'b) -> 'a list -> 'b list

same result as List.map

val map_local_fold : f:('a -> 'b) -> fold:('c -> 'b -> 'c) -> 'c -> 'a list -> 'c

map_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 -> 'c

same specification as above

val map_fold_ac : f:('a -> 'b) -> fold:('b -> 'b -> 'b) -> 'b -> 'a list -> 'b

same 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 -> 'b

map_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