Expressions and operators

Empty parentheses form the unit literal (). Parentheses around one expression explicitly group that expression. A parenthesized comma list is rejected during parsing with TPZ2001. Postfix extensions attach to the preceding expression in source order.

A control operand has a required outer pair of parentheses. The construct consumes that pair and parses its contents with the ordinary expression grammar. Record construction, record update, and lambdas keep the same forms they have in a binding or call argument. Their result types are checked separately.

Omitting the required pair is rejected during parsing with TPZ2001. Extra parentheses inside the pair retain ordinary grouping. The existing concurrent(timeout: expression) argument list already delimits its timeout expression. A loop has no operand.

Higher rows bind more tightly. These rows specify parser grouping. Operand-type acceptance is checked separately.

A prefix on the left applies outside power. The right operand of ** admits unary syntax. The range row accepts the by step clause.

Prefix + is rejected during parsing with TPZ2001. Use the operand directly. Binary + remains addition.

Literal sign rules are defined by Literals and templates. Other operand families remain Pending.

The following operand pairs produce the listed result types.

Mixed int/float operands are rejected during checking. Integer and Length value boundaries are specified below.

Integer arithmetic stays within -9223372036854775808 through 9223372036854775807. Division truncates toward zero. A nonzero remainder has the dividend's sign. Integer 0 ** 0 is 1.

Length operations use the following operand pairs. U denotes the same unit on both Length operands. Mixed units are rejected during checking.

Length multiplication and integer division round to the nearest representable fixed-precision value, with ties choosing the even value. Dividing two Length values gives their floating-point ratio.

When a constant initializer reaches a numeric fault, checking rejects it with TPZ5001 and a message beginning constant expression error:.

==, != compare equality, and <, <=, >, >= compare order. The operands must have compatible, comparable types. These operations produce bool. Comparison capabilities are defined by Protocols and implementations. A declared nominal Eq or Order conformance supplies both its protocol-qualified method and the corresponding operators. Nested derived comparisons use that same conformance.

Write element membership as element in container. in produces bool for Array<T>, Set<T>, Range<int>. The value must be compatible with the container's element type. Range membership requires both bounds and step alignment. Map, string are rejected as membership containers during checking.

Substring search and Map key lookup follow their distinct library contracts.

The left operand is evaluated first. The following cases skip the right operand and produce the indicated value. Otherwise, the right operand is evaluated and supplies the result.

Binary expressions evaluate their operands from left to right. The same order applies within nested operands. The first runtime fault terminates evaluation, so later operands do not run. The short-circuit rule still determines whether a right operand runs.

A fault in an earlier assignment step prevents later steps. Assignment does not give a named record field a read before its right-hand value.

Both endpoints are required and have type int. The result has type Range<int>.

The by clause supplies an int step. Its default is 1. The sequence begins at the first endpoint and advances by adding the step. A positive step advances toward an increasing end value. A negative step advances toward a decreasing end value. Bounds in the wrong direction produce an empty range.

Membership requires bounds and step alignment. A zero step is invalid. A statically detected zero step is rejected during checking. A zero step that reaches evaluation causes a runtime fault. Iteration is defined by Blocks and control flow.

object.member follows the selected type or library entry's member contract. array[index] accepts an int index into Array<T> and produces T. Indices start at 0. Other index types are rejected during checking. Negative or out-of-bounds indices cause a runtime fault.

object?.member accepts Option<T>, T | null.

text.scalars() returns Array<string> in source order. Each element contains one Unicode scalar value. Empty text returns an empty array. The operation preserves the stored scalars without normalization. Joining its elements with an empty separator reproduces the original string.

text.graphemes() follows the Unicode grapheme contract. Use the returned array's length and indexing operations for the chosen text unit.

Loop inputs follow the iteration rule. Choose scalar values or grapheme clusters explicitly before iterating over text.

Write calls as callee(arguments) and members as value.member. Bind an intermediate value with let when it must be evaluated once or reused.

Method chains and successive let bindings read from the input through its transformations in order.

|> is rejected during parsing with TPZ2001. This includes bare-callable, inserted-argument, placeholder, and member-shortcut stages. A standalone expression _ is also rejected during parsing.

When migrating a pipeline with effects, bind the input first, then evaluate the callee and written arguments in their required order. The resulting ordinary call follows Functions and generics.

Compose calls in a function body, for example (value: T) => second(first(value)). Input, intermediate, and result types follow ordinary function and call rules.

The body can name successive results with let in data-flow order.

The >> composition operator is rejected during parsing with TPZ2001. Bind function values before constructing the lambda when their evaluation or capture must happen once.