Dada source files are encoded as UTF-8.

The lexer produces a sequence of tokens:

Token ::= Identifier
          | Keyword
          | Literal
          | Operator
          | Delimiter

A token Token is one of the following kinds:

Each token records whether it was preceded by whitespace, a newline, or a comment. This information is used by the parser but does not produce separate tokens.

Whitespace characters (spaces, tabs, and other Unicode whitespace excluding newlines) separate tokens but are otherwise not significant.

Newline characters (\n) are tracked by the lexer. Whether a token is preceded by a newline may affect how the parser interprets certain constructs.

A comment begins with # and extends to the end of the line.

The content of a comment, including the leading #, is ignored by the lexer. A comment implies a newline for the purpose of preceding-whitespace tracking.

An identifier Identifier begins with a Unicode alphabetic character or underscore (_), followed by zero or more Unicode alphanumeric characters or underscores, provided it is not a keyword Keyword:

Identifier ::= (Alphabetic | _) (Alphanumeric | _)*    (not a Keyword)

Identifiers are case-sensitive.

The following words are reserved as keywords:

Keyword ::= as
            | async
            | await
            | class
            | else
            | enum
            | export
            | false
            | fn
            | give
            | given
            | if
            | is
            | let
            | match
            | mod
            | mut
            | my
            | our
            | perm
            | pub
            | ref
            | return
            | self
            | share
            | shared
            | struct
            | true
            | type
            | unsafe
            | use
            | where

The following single characters are recognized as operator tokens:

Operator ::= + | - | * | / | % | = | !
           | < | > | & | | | : | , | . | ; | ?

• .plus +
• .minus -
• .star *
• .slash /
• .percent %
• .equals =
• .bang !
• .less-than <
• .greater-than >
• .ampersand &
• .pipe |
• .colon :
• .comma ,
• .dot .
• .semicolon ;
• .question ?

Multi-character operators such as &&, ||, ==, <=, >=, and -> are formed by the parser from adjacent operator tokens.

A delimited token contains a matched pair of brackets and their contents:

Delimiter ::= ( Token* ) | [ Token* ] | { Token* }

• .parentheses Parentheses: ( and ).
• .square-brackets Square brackets: [ and ].
• .curly-braces Curly braces: { and }.

Delimiters must be balanced. An opening delimiter without a matching closing delimiter is an error.

The lexer tracks delimiter nesting. Content between matching delimiters is treated as a unit, which enables deferred parsing of function bodies and other nested structures.

A literal Literal is one of the following:

Literal ::= IntegerLiteral
            | BooleanLiteral
            | StringLiteral

An integer literal IntegerLiteral is a sequence of one or more ASCII decimal digits (0–9), optionally separated by underscores (_) that do not affect the value:

IntegerLiteral ::= Digit (_? Digit)*
Digit ::= 0 | 1 | ... | 9

The keywords true and false are boolean literals:

BooleanLiteral ::= true | false

String literal syntax is specified in String Literals.

Characters that do not begin a valid token are accumulated and reported as a single error spanning the invalid sequence.

A Dada source file defines a module. The module name is derived from the file name. A source file contains zero or more items, optionally followed by zero or more statements:

SourceFile ::= Item* Statement*

If a source file contains top-level statements, they are wrapped in an implicit async fn main() function.

An item Item is one of the following:

Item ::= Function
         | Class
         | Struct
         | UseDeclaration

Items and fields may have a visibility modifier. Without a modifier, the item is private to the enclosing module.

Visibility ::= pub
               | export
               | ε

A function Function is declared with the fn keyword, optionally preceded by effect keywords and followed by a name, optional generic parameters, parameters, optional return type, optional where clause, and a body or semicolon:

Function ::= Visibility Effect* fn Identifier GenericParameters?
             ( Parameters ) ReturnType? WhereClause? FunctionBody

Effect keywords may appear in any order before fn:

Effect ::= async
           | unsafe

Function parameters are enclosed in parentheses and separated by commas:

Parameters ::= FunctionInput,*
FunctionInput ::= SelfParameter | Parameter

A function may have a self parameter as its first parameter, optionally preceded by a permission keyword, which makes it a method:

SelfParameter ::= PermissionKeyword? self

Each non-self parameter has the form name: Type. A parameter may be preceded by mut to declare a mutable binding:

Parameter ::= mut? Identifier : Type

A function may have a body, which is a block enclosed in curly braces. If no body is present, the function has no definition.

FunctionBody ::= Block | ε

A function may declare a return type with -> followed by a Type after the parameters.

ReturnType ::= -> Type

A function may declare generic parameters in square brackets after the name:

GenericParameters ::= [ GenericParameter,* ]
GenericParameter ::= type Identifier | perm Identifier

• .type-parameters A type parameter type followed by a name: type T.
• .permission-parameters A permission parameter perm followed by a name: perm P.

A function may have a where clause after the return type that constrains its generic parameters:

WhereClause ::= where WhereConstraint,+
WhereConstraint ::= Type is WhereKind (+ WhereKind)*
WhereKind ::= ref
              | mut
              | shared
              | unique
              | owned
              | lent

A class Class is declared with the class keyword. Classes have reference semantics.

Class ::= Visibility class Identifier GenericParameters?
          ConstructorFields? WhereClause? ClassBody?

A class may declare constructor fields in parentheses after the name:

ConstructorFields ::= ( Field,* )

A class body enclosed in curly braces may contain field declarations and method definitions:

ClassBody ::= { ClassMember* }
ClassMember ::= Field
                | Method

A method Method is a function declared inside a class or struct body:

Method ::= Function

A field declaration Field has the form:

Field ::= Visibility mut? Identifier : Type

Classes support generic parameters and where clauses with the same syntax as functions.

A struct Struct is declared with the struct keyword. The syntax is identical to Class but structs have value semantics.

Struct ::= Visibility struct Identifier GenericParameters?
           ConstructorFields? WhereClause? ClassBody?

A use declaration UseDeclaration imports a name from another crate, optionally renaming it with as:

UseDeclaration ::= use Path (as Identifier)?
Path ::= Identifier (. Identifier)*

A block Block is a sequence of zero or more statements enclosed in curly braces:

Block ::= { Statement* }

A block evaluates to the value of its last expression, if the last statement is an expression statement.

A statement Statement is one of the following:

Statement ::= LetStatement
              | ExprStatement

A let statement LetStatement introduces a new variable binding:

LetStatement ::= let mut? Identifier (: Type)? (= Expr)?

A let statement may include a type annotation: let name: Type = value.

A let statement may use mut to declare a mutable binding: let mut name = value.

The initializer (= value) is optional. A variable may be declared without an initial value.

An expression statement ExprStatement is an expression followed by a newline or end of block:

ExprStatement ::= Expr

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

A type may be a simple name: String, i32, bool.

A type may be a dotted path: module.Type.

A type may be applied to generic arguments in square brackets: Vec[String], Pair[i32, bool].

A type may be preceded by a permission to form a permission-qualified type: my String, ref Point, mut Vec[i32].

The following permission keywords are available:

• .my my — exclusive ownership.
• .our our — shared ownership.
• .ref ref — immutable reference.
• .mut mut — mutable reference.
• .given given — a permission supplied by the caller.

The permissions ref, mut, and given may include a place list in square brackets specifying which places they refer to: ref[x, y], mut[self], given[p].

The place list is optional. When omitted, the permission applies without place restrictions.

A generic type parameter is declared as type T.

A generic permission parameter is declared as perm P.

A single identifier in a generic position is ambiguous between a type and a permission. The ambiguity is resolved during type checking, not parsing.

There are multiple forms of string literals:

• .quoted Single-quoted string literals begin with a " and end with a ".
• .triple-quoted Triple-quoted string literals begin with a """ and end with a """.

The syntax """ is interpreted as the start of a triple-quoted string literal and not a single-quoted string literal followed by the start of another single-quoted string literal.

A triple-quoted string literal cannot contain three consecutive unescaped double-quote characters.

String literals have type my String.

String literals support the following escape sequences:

• .backslash \\ produces a literal backslash.
• .double-quote \" produces a literal double quote.
• .newline \n produces a newline.
• .carriage-return \r produces a carriage return.
• .tab \t produces a tab.
• .open-brace \{ produces a literal {.
• .close-brace \} produces a literal }.

The \" escape sequence is not needed in triple-quoted strings, since embedded double quotes do not terminate the string.

A \ followed by a character not listed above is an error.

String literals may contain interpolation expressions delimited by curly braces ({ and }). Any valid Dada expression may appear inside the braces.

Literal brace characters are produced by the \{ and \} escape sequences.

The lexer tracks brace nesting depth, so that braces within interpolated expressions (e.g., block expressions, struct literals) do not prematurely terminate the interpolation.

Quotes inside interpolated expressions do not terminate the enclosing string literal.

Interpolated expressions are evaluated at runtime in the enclosing scope.

Interpolated expressions are evaluated left-to-right.

Each interpolated expression must produce a value that can be converted to a string. This is checked at compile time.

The permission system applies normally to interpolated expressions.

A string literal that begins with a newline immediately after the opening quote (either " or """) is a multiline string literal with automatic indentation handling.

The leading newline immediately after the opening quote is removed.

The trailing newline immediately before the closing quote is removed, along with any whitespace on the final line.

The common whitespace prefix across all non-empty lines is removed from the start of each line.

Escape sequences are part of the string content, not whitespace. They are not affected by leading/trailing stripping or dedenting.

A string literal beginning with "\ followed by a newline disables automatic dedenting. The string preserves its content exactly as written, including the leading newline and all indentation.

Interpolated expressions must produce values that can be converted to strings. The exact conversion mechanism is not yet defined and depends on Dada’s trait/interface system.