An expression Expr is parsed using precedence climbing. From lowest to highest precedence:

Expr ::= AssignExpr

The assignment operator = assigns a value to a place expression. It has the lowest precedence among binary operators:

AssignExpr ::= OrExpr

The logical OR operator || performs short-circuit boolean logic:

OrExpr ::= AndExpr

The logical AND operator && performs short-circuit boolean logic:

AndExpr ::= CompareExpr

The comparison operators compare two values and produce a boolean result:

CompareExpr ::= AddExpr

CompareOp ::= == | < | > | <= | >=

The additive operators perform addition and subtraction:

AddExpr ::= MulExpr

The multiplicative operators perform multiplication and division:

MulExpr ::= UnaryExpr

A unary expression applies a prefix operator to a postfix expression:

UnaryExpr ::= UnaryOp* PostfixExpr
UnaryOp ::= ! | -

• .not ! performs logical negation.
• .negate - performs arithmetic negation.

A binary operator must appear on the same line as its left operand. An operator on a new line begins a new expression or is interpreted as a prefix operator.

A postfix expression applies zero or more postfix operators to a primary expression:

PostfixExpr ::= PrimaryExpr PostfixOp*

A postfix operator PostfixOp is one of the following:

PostfixOp ::= FieldAccess
              | Call
              | Await
              | PermissionOp

A field access FieldAccess uses dot notation to access a field or name a method:

FieldAccess ::= . Identifier

A function or method call Call follows an expression with parenthesized arguments separated by commas. The opening parenthesis must appear on the same line as the callee:

Call ::= ( Expr,* )

The .await postfix operator awaits the result of a future:

Await ::= . await

A permission operation PermissionOp requests specific permissions on a value:

PermissionOp ::= give
                 | share
                 | lease
                 | ref

A primary expression PrimaryExpr is one of the following:

PrimaryExpr ::= Literal
                | identifier
                | self
                | IfExpr
                | ReturnExpr
                | ConstructorExpr
                | paren-expr
                | block-expr

An if expression IfExpr evaluates a condition and executes a block:

IfExpr ::= if Expr Block (else if Expr Block)* (else Block)?

An if expression may have an else clause.

Multiple conditions may be chained with else if.

A return expression ReturnExpr exits the enclosing function, optionally with a value. The value, if present, must appear on the same line as return:

ReturnExpr ::= return Expr?

A constructor expression ConstructorExpr creates a new instance of a class or struct. The opening brace must appear on the same line as the type name:

ConstructorExpr ::= Identifier { ConstructorField,* }
ConstructorField ::= Identifier : Expr