Mark a function async to have it return a promise; inside, await pauses until the awaited promise settles.

$\langle\!\langle A\rangle\!\rangle\varphi$ quantifies over strategies rather than paths: whatever the agents outside $A$ do, the coalition $A$ can force $\varphi$. With $A$ empty it collapses to CTL’s “all paths”; with $A$ everyone, to “some path”.

Multiplicative resources become copyable when marked $!A$, letting you recover classical behaviour where needed.

SAT instances are expressed over Boolean variables; each variable can appear positive or negated in clauses.

Returns {:ok, ast} or {:error, reason}. Use the bang variant Code.string_to_quoted!/1 to raise on parse failure. Every node in the resulting AST is a {form, metadata, args} tuple; pass columns: true and token_metadata: true for full position information.

$C_G \varphi$ abbreviates the infinite conjunction $E_G\varphi \wedge E_G E_G\varphi \wedge \dots$, where $E_G$ means “everyone in $G$ knows”. Unattainable over unreliable channels, per the coordinated attack argument.

Example: $\exists x \in \mathbb{R},\ x^2 = 2$. In type theory this corresponds to dependent sums.

Use for await...of on objects implementing Symbol.asyncIterator, including many Node streams and custom async generators.

Generator function declaration syntax. The asterisk (*) indicates the function is a generator that can yield multiple values over time. When called, returns an iterator object. Combined with async, creates async generators for async iteration.

HashMap stores unique keys mapped to values; ownership is transferred into the map, and lookups are O(1) on average. Construct with HashMap::new() or HashMap::from.

Import via use std::iter::Iterator; and rely on adapters like map, filter, and collect for chaining.

$K_a \varphi$ holds when $\varphi$ is true in every world agent $a$ cannot distinguish from the actual one. Operators nest: $K_a K_b \varphi$ says $a$ knows that $b$ knows $\varphi$, the currency in which protocols trade.

$\square\varphi$ (also written $\mathbf{G}\varphi$) asserts $\varphi$ at every state from now on. Safety properties take this shape: $\square\,\neg\mathit{bad}$, nothing bad ever happens.

$\lozenge\varphi$ (also written $\mathbf{F}\varphi$) asserts $\varphi$ at some state from now on. Liveness properties take this shape: $\lozenge\,\mathit{done}$, something good eventually happens. Dual to $\square$: $\lozenge\varphi \equiv \neg\square\neg\varphi$.

Calls fun.(node, acc) on each node before visiting its children, returning {new_node, new_acc}. Use to collect information from or transform an AST without manually recursing. Macro.postwalk/3 visits children first; Macro.traverse/4 gives both pre- and post-visit hooks.

In reductions to SAT, mutual exclusion is encoded by pairing negated literals to forbid simultaneous truth assignments.

$A \mathbin{\parr} B$ expects a consumer ready for either side, and $(A \otimes B)^{\perp} = A^{\perp} \mathbin{\parr} B^{\perp}$.

$x(y).P$ waits for a name on channel $x$ and binds it to $y$ within $P$. The parenthesised $y$ is a binder, like the $\lambda$ in $\lambda y.M$: after a communication delivering $z$, the receiver continues as $P\lbrace z/y\rbrace$.

$0$ is the process that does nothing. Every finite behaviour bottoms out in $0$, and trailing occurrences are conventionally omitted: $\bar{x}\langle y\rangle$ abbreviates $\bar{x}\langle y\rangle.0$.

$\bar{x}\langle y\rangle.P$ offers the name $y$ on channel $x$. The send blocks until a matching input on $x$ is available; the two synchronise and the sender continues as $P$. What travels is always a name, never a process.

$P \mid Q$ places two processes side by side. They proceed independently, except where one offers an output and the other an input on the same channel, in which case they may synchronise. Composition is commutative and associative up to structural congruence.

$!P$ satisfies $!P \equiv P \mid\, !P$: a copy of $P$ can always be peeled off. Replication supplies unbounded behaviour without recursive definitions; $!x(y).Q$ is the idiom for a persistent server that handles any number of requests on $x$.

$(\nu x)P$ (“new $x$ in $P$”) creates a fresh channel visible only within $P$. Privacy is not permanent: if $P$ sends $x$ to an outside process, the scope of the restriction extrudes to cover the recipient, which is how private connections are established dynamically.

$P + Q$ offers the initial actions of both branches; the first to communicate wins and the alternative is discarded. A sum of input prefixes, $x(y).P + z(w).Q$, is the calculus’s analogue of a selective receive over several channels.

Promises model async results and support chaining via then() and catch(), or awaiting inside async functions.

Read left to right as the protocol of one endpoint: $!T.S$ sends a value of type $T$ and continues as $S$; $?T.S$ receives one; $\mathbf{end}$ closes the session. The peer endpoint holds the dual type, ${?}\mathsf{Int}.\,{!}\mathsf{Bool}.\,\mathbf{end}$, every send matched by a receive. Branching protocols add internal choice $\oplus\lbrace l_i : S_i\rbrace$ and external choice $\&\lbrace l_i : S_i\rbrace$ over labelled alternatives.

$A \otimes B$ consumes both resources together and is dual to $\parr$ under linear negation.

Example: $\forall x \in \mathbb{N},\ x \ge 0$. In type theory this corresponds to dependent products.

Vectors own contiguous elements on the heap and support push/pop; you create them with Vec::new() or vec![] literal syntax.

$?A$ restores weakening and contraction dually to $!A$, signalling that the resource can be duplicated or discarded.