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

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.

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.

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}$.

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

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

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

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.