grammar.ebnf

Program = { Item } ;
Item    = ImportItem
        | SingletonDeclaration
        | [ 'pub' ] , TypeDefinition
        | [ 'pub' ] , LetStatement
        | [ 'pub' , 'event' ] , FunctionDefinition
        | ImplBlock ;

(*
  Function
*)
FunctionDefinition = 'fn' , ident , '(' , [ parameterList ] , ')'
                   , [ '->' , Type ] , Block ;
ParameterList      = parameter , { ',' , parameter } , [ ',' ] ;
Parameter          = ident , ':' , Type ;

Block = '{' , { Statement } , [ Expression ] , '}' ;

(*
  Types
*)
SingletonDeclaration               = singletonIdent , '=' , SingletonType
                                   , ';' ;
SingletonType                      = ident | listType | singletonObjectType
                                   | optionType ;
singletonObjectType                = '{' , [ singletonObjectTypeFieldList ]
                                   , '}' ;
singletonObjectTypeFieldList       = singletonObjectTypeField
                                   , { ',' , singletonObjectTypeField }
                                   , [ ',' ] ;
singletonObjectTypeField           = [ singletonObjectTypeFieldAnnotation ]
                                   , objectTypeField ;
singletonObjectTypeFieldAnnotation = '@' , ident ;

TypeDefinition = 'type' , ident , '=' , Type , ';' ;
Type           = ident | singletonIdent | listType | objectType
               | optionType ;
listType       = '[' , Type , ']' ;

objectType          = '{' , [ objectTypeFieldList ] , '}' ;
objectTypeFieldList = objectTypeField , { ',' , objectTypeField }
                    , [ ',' ] ;
objectTypeField     = ( ident | string ) , ':' , Type ;

optionType = '?' , Type ;

(*
  Statements
*)
Statement = TypeDefinition | LetStatement | ReturnStatement | BreakStatement
          | ContinueStatement | LoopStatement | WhileStatement
          | ForStatement | ExpressionStatement | TriggerStatement ;

(* Let statement *)
LetStatement = 'let' , ident , [ ':' , Type ] , '=' , Expression
             , ';' ;

(* Return statement *)
ReturnStatement = 'return' , [ Expression ] , ';' ;

(* Brak statement *)
BreakStatement = 'break' , ';' ;

(* Continue statement *)
ContinueStatement = 'continue' , ';' ;

(* Loop statement *)
LoopStatement = 'loop' , Block , [ ';' ] ;

(* While statement *)
WhileStatement = 'while' , Expression , Block , [ ';' ] ;

(* For statement *)
ForStatement = 'for' , ident , 'in' , Expression , Block , [ ';' ] ;

(* Expression statement *)
ExpressionStatement = ExpressionWithoutBlock , ';'
                    | ExpressionWithBlock , [ ';' ] ;

(* Trigger Statement *)
TriggerDispatchKind = 'on' | 'at' ;
TriggerStatement    = 'trigger' , ident , TriggerDispatchKind
                    , ident , '(' , [ callArguments ] , ')' , ';' ;

(* Import item *)
ImportItem = 'import' , ( [ 'type' , 'templ' ] , ident
                        | '{' , [ 'type' , 'templ' ] , ident
                        , { ',' , [ 'type' , 'templ' ] , ident }
                        , [ ',' ] , '}' ) , 'from' , ident , ';' ;

(* Impl block *)
ImplBlock = 'impl' , ident , [ 'with' , '{' , ident , { ',' , ident }
                             , [ ',' ] , '}' ] , 'for' , singletonIdent
          , '{' , { FunctionDefinition } , '}' ;

(*
  Expressions
*)
Expression          = ExpressionWithBlock | ExpressionWithoutBlock ;
ExpressionWithBlock = Block | IfExpression | MatchExpression
                    | TryExpression ;

(* If expression *)
IfExpression = 'if' , Expression , Block , [ 'else' , Expression
                                           , Block ] ;

(* Match expression *)
MatchExpression = 'match' , Expression , '{' , [ matchArm , { ','
                                                            , matchArm }
                                               , [ ',' ] ] , '}' ;
matchArm        = matchLiteral , '=>' , ( ExpressionWithoutBlock
                                        , ','
                                        | ExpressionWithBlock ) ;
matchLiteral    = LiteralExpression | ( PREFIX_OPERATOR , LiteralExpression )
                | '_' ;

(* Try expression *)
TryExpression = 'try' , Block , 'catch' , ident , block ;

ExpressionWithoutBlock = IdentExpr
                       | singletonIdent
                       | LiteralExpression
                       | '(' , Expression , ')'
                       | PrefixExpression
                       | InfixExpression
                       | AssignExpression
                       | CallExpression
                       | IndexExpression
                       | MemberExpression
                       | CastExpression
                       | SpawnExpression ;

IdentExpr = ident ;

LiteralExpression = number | boolean | string | 'null' | 'none'
                  | RangeLiteral | ListLiteral | ObjectLiteral
                  | FunctionLiteral ;

(* Range literal expression *)
RangeLiteral = Expression , '..' , Expression ;

(* List literal expression *)
ListLiteral = '[' , [ Expression , { ',' , Expression } , [ ',' ] ]
            , ']' ;

(* Object literal expression *)
ObjectLiteral      = 'new' , '{' , [ objectLiteralField , { ','
                                                          , objectLiteralField }
                                   , [ ',' ] ] , '}' ;
objectLiteralField = ( ident | string ) , ':' , Expression ;

(* Function literal expression *)
FunctionLiteral = 'fn' , '(' , [ parameterList ] , ')' , [ '->'
                                                         , Type ]
                , Block ;

(* Prefix expression *)
PrefixExpression = PREFIX_OPERATOR , Expression ;

(* Infix expression *)
InfixExpression = Expression , INFIX_OPERATOR , Expression ;

(* Assign expression *)
AssignExpression = Expression , ASSIGN_OPERATOR , Expression ;

(* Call expression *)
CallExpression = Expression , '(' , [ callArguments ] , ')' ;
callArguments  = Expression , { ',' , Expression } , [ ',' ] ;

(* Member expression *)
MemberExpression = Expression , '.' , ident ;

(* Index expression *)
IndexExpression = Expression , '[' , Expression , ']' ;

(* Cast expression *)
CastExpression = Expression , 'as' , Type ;

(* Spawn expression *)
SpawnExpression = 'spawn' , ident , '(' , [ callArguments ] , ')' ;

(*
  Tokens
*)
singletonIdent = '$' , ident ;
ident          = LETTER , { LETTER | DIGIT }- ? any keyword ? ;
number         = DIGIT , { DIGIT | '_' } , [ 'f'
                                           | '.' , DIGIT , { DIGIT
                                                           | '_' } ] ;
bool           = 'true' | 'false' | 'on' | 'off' ;
string         = '"' , { CHAR - ( '"' | '\' ) | escape_seq }
               , '"'
               | "'" , { CHAR - ( "'" | '\' ) | escape_seq }
               , "'" ;
escape_seq     = '\' , ( ESCAPE_CHAR
                       | 3 * OCTAL
                       | 'x' , 2 * HEX
                       | 'u' , 4 * HEX
                       | 'U' , 8 * HEX ) ;

comment = '//' , { CHAR } , ? LF ?
        | '/*' , { CHAR } , '*/' ;

LETTER      = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I'
            | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R'
            | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | 'a'
            | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j'
            | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's'
            | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '_' ;
OCTAL       = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' ;
DIGIT       = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8'
            | '9' ;
HEX         = DIGIT | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'a'
            | 'b' | 'c' | 'd' | 'e' | 'f' ;
CHAR        = ? any UTF-8 character ? ;
ESCAPE_CHAR = '\' | 'b' | 'n' | 'r' | 't' ;

PREFIX_OPERATOR     = '!' | '-' | '?' ;
INFIX_OPERATOR      = ARITHMETIC_OPERATOR | RELATIONAL_OPERATOR
                    | BITWISE_OPERATOR | LOGICAL_OPERATOR ;
ARITHMETIC_OPERATOR = '+' | '-' | '*' | '/' | '%' | '**' ;
RELATIONAL_OPERATOR = '==' | '!=' | '<' | '>' | '<=' | '>=' ;
BITWISE_OPERATOR    = '<<' | '>>' | '|' | '&' | '^' ;
LOGICAL_OPERATOR    = '&&' | '||' ;
ASSIGN_OPERATOR     = '=' | '+=' | '-=' | '*=' | '/=' | '\='
                    | '%=' | '**=' | '<<=' | '>>=' | '|=' | '&='
                    | '^=' ;