Deflation is an execution mechanism which extracts a single value from an expression that might publish many values, so that such an expression can be executed in a context that expects at most one value.

A expression E is deflated to a value v in a context C by rewriting

C{E}

to

C{x} <x< E

When E publishes a value v, that value is bound to x and used in the context C, and E is killed.

The context C may contain multiple expressions to be deflated, so this transformation may be applied multiple times. For example, the expression

(E, F, G)

rewrites to

(x, y, z) <x< E <y< F <z< G

If any deflated expression halts silently, then the enclosing expression also halts silently. In the example above, if F halted silently, then the expression (E, F, G) would also halt silently.

However, there is one exception to this rule: if C is a function call it does not halt, since function evaluation is lenient.

Notice that each deflated expression is evaluated concurrently, due to the behavior of the pruning combinator. This is what makes Orc a functional concurrent language: when an expression is evaluated recursively, all such evaluations take place simultaneously.