Конкурентность

Each concurrent arm has the form name: expression, where name is an identifier.

A concurrent group may contain zero arms. An untimed empty group completes immediately with the zero-field structural record. Its type is written {} in type positions, and it is distinct from unit (). The ordinary empty expression block {} retains its unit result.

A timed empty group evaluates its Duration expression exactly once before the group, then follows the same deadline/completion arbitration as every timed group. A zero deadline selects the else block. The fallback must satisfy the same zero-field record result type. An untimed concurrent {} can supply that value.

The concurrent(timeout: ...) form requires an else block. An else block requires the timeout form. Either missing partner is rejected with TPZ2005.

The timeout operand is an ordinary expression whose resolved type is Duration. Parentheses, bindings, calls, and conditionals obey the same expression and type rules. An int or float does not implicitly convert to Duration. An incompatible operand produces TPZ5001 during checking. Evaluate the operand exactly once, before starting its deadline or any arm. If that evaluation fails, propagate its original failure and location without starting an arm or evaluating the fallback. After it succeeds, start the deadline and apply the existing completion/deadline arbitration. A zero deadline wins even against immediately ready arms.

Arm names in one concurrent expression must be distinct. A repeated arm name is rejected with TPZ5008.

When the arm result types are known, a concurrent expression has a structural record type. Each arm name becomes a field name. Each field type is the widened type inferred for its arm expression.

Arms resolve enclosing names using the ordinary lexical rules. Names introduced inside an arm block stay in that block. Arm labels name result fields and do not introduce bindings. Start order, completion order, and interleaving of visible effects are unspecified. Read completed fields after the expression returns when output order matters.

Each concurrent arm is an independent control boundary. A return or postfix ? cannot target a function outside the arm. A break or continue cannot target an outer loop. Missing arm-local function or unlabelled loop targets are rejected during checking with TPZ5001. A loop label without a target inside the arm is rejected during checking with TPZ5720. Functions called by the arm and loops introduced inside it consume their own control transfers.

When every arm finishes successfully before any applicable timeout, the concurrent expression produces a record containing the named arm values.

An arm that completes with an ordinary Result value stores that value in its result field, preserving Ok(...) or Err(...). The concurrent expression does not apply postfix propagation to that value.

If an arm reports an execution failure before the timeout is reached, that failure leaves the concurrent expression without evaluating its fallback. The same failure transfer applies to the form without a timeout.

When the deadline is reached before all arms complete, or coincides with completion, unfinished arms are abandoned and collected result values are discarded. The concurrent expression then evaluates its else block.

Timeout takes priority when reaching the deadline coincides with arm completion, including a zero-millisecond timeout. The else block determines the result in that case. When arm faults occur simultaneously, arm declaration order gives no fault priority.

A timed concurrent reaches its fallback after the deadline even when an arm cannot finish, including an infinite loop or deep recursion. A host call already in progress finishes without interruption and can delay group completion. An abandoned arm produces no effects after the group finishes. Effects that occurred before completion remain. A group without a timeout makes no fairness guarantee.

A concurrent arm abandoned by a deadline does not execute its remaining defer blocks or using cleanup. Normal block completion and structured exits through return, break, continue, or an Err from ? run language cleanup. Abandonment follows the same cleanup rule as an ordinary runtime fault →. Cleanup performed by an arm that completed before the deadline remains observable. Host resource handles follow runtime reclamation →.

When the group finishes, the runtime reclaims host resource handles opened by an abandoned arm, such as File handles. This reclamation is performed by the runtime and does not execute the arm's remaining language cleanup.

Duration conversion and bounds →

Duration conversion and bounds →

When the arm result types are known, a value-producing fallback is checked against their record type. A fallback that terminates control flow is checked without that expected result type.