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)*