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

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

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

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

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

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

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.

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

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

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

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