`S.TERM`

`val active : Output.active -> 'a t`

`active x`

is a term indicating that the result is not determined yet.

`val return : ?label:string -> 'a -> 'a t`

`return x`

is a term that immediately succeeds with `x`

.

`val fail : string -> 'a t`

`fail m`

is a term that immediately fails with message `m`

.

```
val state :
?hidden:bool ->
'a t ->
('a, [ `Active of Output.active | `Msg of string ]) Stdlib.result t
```

`state t`

always immediately returns a successful result giving the current state of `t`

.

`catch t`

successfully returns `Ok x`

if `t`

evaluates successfully to `x`

, or successfully returns `Error e`

if `t`

fails with error `e`

. If `t`

is active then `catch t`

will be active too.

`map f x`

is a term that runs `x`

and then transforms the result using `f`

.

The optional equality function `?eq`

defaults to physical equality. When `f`

produces an updated result following a change in `x`

, the equality function will be called with the previous and the new value `eq b_old b_new`

: returning `true`

indicates that the change can be ignored and should not propagate further down the pipeline.

`map_error f x`

is a term that runs `x`

and then transforms the error string (if any) using `f`

.

`pair a b`

is the pair containing the results of evaluating `a`

and `b`

(in parallel).

```
val list_map :
(module ORDERED with type t = 'a) ->
?collapse_key:string ->
?label:string ->
('a t -> 'b t) ->
'a list t ->
'b list t
```

`list_map (module T) f xs`

adds `f`

to the end of each input term and collects all the results into a single list.

```
val list_iter :
(module ORDERED with type t = 'a) ->
?collapse_key:string ->
?label:string ->
('a t -> unit t) ->
'a list t ->
unit t
```

Like `list_map`

but for the simpler case when the result is unit.

`list_seq x`

evaluates to a list containing the results of evaluating each element in `x`

, once all elements of `x`

have successfully completed.

`option_map f x`

is a term that evaluates to `Some (f y)`

if `x`

evaluates to `Some y`

, or to `None`

otherwise.

Like `option_map`

but for the simpler case when the result is unit.

`option_seq None`

is `Current.return None`

and `option_seq (Some x)`

is `Current.map some x`

. This is useful for handling optional arguments that are currents.

`all xs`

is a term that succeeds if every term in `xs`

succeeds. The labels are used if some terms fail, to indicate which ones are failing.

`gate ~on:ctrl x`

is the same as `x`

, once `ctrl`

succeeds.

Note: `gate`

does *not* delay `x`

; it only delays whatever you put after the gate. e.g.

```
let binary = build src in
let tests_ok = test binary in
binary |> gate ~on:tests_ok |> deploy
```

`cutoff ~eq x`

is the same as `x`

, but changes to `x`

that are equal according to `eq`

do not propagate further down. It should be used when values of type `'a`

have a precise definition of equality to avoid triggering redundant work.

`collapse ~key ~value ~input t`

is a term that behaves just like `t`

, but when shown in a diagram it can be expanded or collapsed. When collapsed, it is shown as "input -> `+`

" and the user can expand it to show `t`

instead. The idea is that `input`

is a dependency of `t`

and the "+" represents everything in `t`

after that. `key`

and `value`

are used as the parameters (e.g. in a URL) to control whether this is expanded or not. For example `collapse ~key:"repo" ~value:"mirage/mirage-www" ~input:repo (process repo)`

Note: `list_map ~collapse_key`

provides an easy way to use this.

`collapse_list ~key ~value ~input t`

is a term that behaves just like `t`

list, but when shown in a diagram it can be expanded or collapsed.

`with_context ctx f`

is the term `f ()`

, where `f`

is evaluated in context `ctx`

. This means that `ctx`

will be treated as an input to all terms created by `f`

in the diagrams.

**N.B.** these operations create terms that cannot be statically analysed until after they are executed.

```
val bind :
?info:description ->
?eq:('b -> 'b -> bool) ->
('a -> 'b t) ->
'a t ->
'b t
```

`bind f x`

is a term that first runs `x`

to get `y`

and then behaves as the term `f y`

. Static analysis cannot look inside the `f`

function until `x`

is ready, so using `bind`

makes static analysis less useful. You can use the `info`

argument to provide some information here.

`val primitive : info:description -> ('a -> 'b primitive) -> 'a t -> 'b t`

`primitive ~info f x`

is a term that evaluates `f`

on each new value of `x`

. This is used to provide the primitive operations, which can then be combined using the other combinators in this module. `info`

is used to label the operation in the diagram.

```
val component :
('a, Stdlib.Format.formatter, unit, description) Stdlib.format4 ->
'a
```

`component name`

is used to annotate binds, so that the system can show a name for the operations hidden inside the bind's function. `name`

is used as the label for the bind in the generated dot diagrams. For convenience, `name`

can also be a format string.

`val observe : 'a t -> 'a Output.Blockable.t`

`observe x`

evaluates the current state of term `x`

. A ``Blocked`

value occurs when the term failed because an upstream dependency errored.

`module Syntax : sig ... end`