#### jenga

Library

Module

Module type

Parameter

Class

Class type

`Tenacious.t`

-- A type for "Tenacious computations".

A value `tenacious`

of type `'a Tenacious.t`

is a recipe for cancellable computation instances, returning certified values of type `'a`

.

When a `tenacious`

is sampled, a fresh "computation instance" begins running. The result of (an uncancelled) computation instance is a value `v`

paired with certificate of validity `h`

. The certificate is invalidated if `h`

breaks.

A computation instance has an associated `cancel`

signal, supplied when the instance was created. If an instance is cancelled, is will start no further leaf computations.

`Tenacious.exec t`

samples a tenacious `t`

, and awaits the certified result `(v,h)`

of the computation instance. The certificate `h`

may already be invalidated when the result is determined.

`Tenacious.embed f`

constructs a `leaf`

tenacious from a thunked deferred computation. A new deferred computation is created (by applying `f`

to a `cancel`

signal) each time `leaf`

is sampled. The deferred computation may not return `None`

unless `leaf`

is cancelled.

`Tenacious.bind t1 f`

construct a `sequenced`

tenacious, such that `f`

is applied to a value `v1`

returned by a computation instance obtained from sampling `t1`

. The tenacious `t2 = f v1`

is then sampled, with a cancel-signal incorporating the certificate `h1`

associated with `v1`

, such that `t2`

is cancelled if ever `v1`

becomes invalidated. If `h1`

is invalid at the time `t2`

has finished, `sequenced`

is re-sampled.

`Tenacious.all children`

constructs a `parent`

tenacious which samples its `children`

concurrently, and waits for them all to finish. Once a child has finished, its certificate is monitored for validity; if the certificate becomes invalid, and some siblings are still running, the invalidated child is re-sampled immediately.

`Tenacious.memoize inner`

constructs an `outer`

tenacious which behaves like `inner`

except a single computation instance obtained from sampling `inner`

is shared between every sampling of `outer`

. It is guaranteed only a single computation instance is ever running at the same time.

`module type S = sig ... end`

`module type For_tests = sig ... end`