An item in the condition of a conditional expression, match expression, or while loop.

The body of a function or subscript implementation.

An access modifier.

A member modifier.

A sequence of binary operations stored as a tree whose structure encodes the evaluation order.

Instances of this type are created during type checking for each SequenceExpr in the program once the precedence groups of its operators have been determined. A tree is created by calling append(operator:right:) to append an operator and its right operand to the sub-sequence represented by self.

The identity of a call expression.

An operator notation.

An operator precedence group.

An access effect, specifying how a parameter, receiver, or remote part is accessed.

A function in the Builtin module, accessible only to the standard library.

Built-in functions implement the basis operations on built-in types such as Builtin.i64, and are implemented by a single IR instruction.

Only a few built-in functions, such as Builtin.address(of:), are truly generic. Others are parameterized by a bounded selection of types and flags, resulting in a family of related non-generic Hylo functions having the same base name. The full name of these functions is a concatenation of the base name with a representation of the value of each parameter, separated by underscores. For example, Builtin.add_i32 and Builtin.add_i64 represent integer addition for 32-bit and 64-bit integer values. Some flags have default values (e.g. OverflowBehavior.ignored), which are omitted from builtin function names. For example:

Most built-in functions have the same semantics an the LLVM instruction with the same base name; the other cases have documentation describing their semantics and Hylo signature. Supported LLVM operations include all arithmetic and comparison instructions on built-in integral and floating-point numbers as well as conversions from and to these types.

A value computed at compile-time.

A reference to a declaration.

The predicate of an integer comparison.

The predicate of an integer comparison.

The result of overflow during mathematical operations.

Notes:

Be careful when writing rules that start with an optional symbol that may be recognized at the beginning of the following construct. A naive combinator may not be able to backtrack. For example:

let p0 = maybe(foo.and(bar)).and(ham)
let p1 = foo.and(bar).or(ham)

Both p0 and p1 will fail to recognize inputs recognized by ham if foo can recognize the same prefix, as the latter will throw a committing failure it applies bar rather than backtracking. A correct definition is:

let p2 = attempt(foo.and(bar)).or(foo)

A namespace for the routines of Hylo’s parser.

The body of a function or method declaration.

A conjunction (&&) or disjunction (||) operator.

Information identifying a run-time argument of a function or subscript call.

How a binding declaration is being used.

The kind of a callable entity.

The outcome of a goal.

The result of a name resolution request.

How a name expression is being used.

A part of a term in a requirement rewriting system.

A built-in type.

The result of a call to a closure passed to TypeProtocol.transform(_:).