Conlang/grammar.ebnf

(* Conlang Expression Grammar *)
Start       = File ;

Mutability  = "mut"? ;
Visibility  = "pub"? ;


File        = Item* EOI ;


Item        = Visibility (
                Const | Static | Module 
                | Function | Struct | Enum 
                | Impl
            ) ;


(* item *)
Const       = "const" Identifier ':' Type = Expr ';' ;

Static      = "static" Mutability Identifier ':' Type = Expr ';' ;

Module      = "mod" Identifier '{' (Item)* '}' ;

Function    = "fn" Identifier '(' (Param ',')* Param? ')' ( '->' Type) Block ;
Param       = Identifier ':' Type ;

Struct      = "struct" Identifier (TupleStruct | StructStruct)?;
StructStruct= '{' (Identifier ':' Type),* '}' ;
TupleStruct = TyTuple ;

Enum        = "enum" Identifier (TupleEnum | StructEnum)? ;
TupleEnum   = TyTuple;
StructEnum  = '{' (Identifier ':' Type)* '}' ;


(* statement *)
Stmt        = ';' | (Let | Item | Expr ';'?) ;
Let         = "let" Mutability Identifier (':' Ty)? ('=' Expr)? ;
(* TODO: Closure syntax *)
Closure     = "cl" '(' Param* ')' Block ;


(* type *)
Ty          = Never | Empty | TyTuple | Path | TyRef | TyFn ;
Never       = '!' ;
Empty       = '(' ')' ;
TyTuple     = '(' (Ty ',')* Ty? ')' ;
TyRef       = ('&' | '&&')* Path ;
TyFn        = "fn" TyTuple (-> Ty)? ;


(* path *)
Path        = '::'? PathPart ('::' PathPart)* ;
PathPart    = "super" | "self" | Identifier ;
Identifier  = IDENTIFIER ;


(* literal *)
Bool        = "true" | "false" ;


(* expr *)
ExprKind    = Assign  | Compare | Range  | Logic    | Bitwise | Shift
            | Factor  | Term    | Unary  | Member   | Call    | Index
            | Path    | Literal | Array  | ArrayRep | AddrOf
            | Block   | Group    
            | While   | If      | For    | Break    | Return  | Continue ;

Expr        = Assign ;

Assign      = Path (AssignOp  Assign ) | Compare ;

Binary      = Compare | Range | Logic  | Bitwise | Shift | Factor | Term ;
Compare     = Range    (CompareOp Range  )* ;
Range       = Logic    (RangeOp   Logic  )* ;
Logic       = Bitwise  (LogicOp   Bitwise)* ;
Bitwise     = Shift    (BitwiseOp Shift  )* ;
Shift       = Factor   (ShiftOp   Factor )* ;
Factor      = Term     (FactorOp  Term   )* ;
Term        = Unary    (FactorOp  Unary  )* ;

Unary       = (UnaryOp)* Member ;

Member      = Call ('.' Call)* ;

Call        = Index  ('(' Tuple? ')')* ;

Index       = Primary ('[' Indices ']')* ;
Indices     = (Expr ',')* Expr? ;

Primary     = Literal | Path  | Array | ArrayRep | AddrOf 
            | Block   | Group 
            | If      | While | For   | Break    | Return | Continue;

Literal     = STRING | CHARACTER | FLOAT | INTEGER | Bool ;

Array       = '[' (Expr ',')* Expr? ']' ;
ArrayRep    = '[' Expr ';' Expr ']' ;

AddrOf      = ('&' | '&&')* Expr ;

Block       = '{' Stmt* '}';

Group       = '(' (Empty | Expr | Tuple) ')' ;
Tuple       = (Expr ',')* Expr? ;
Empty       = ;

While       = "while" Expr Block Else? ;
If          = "if"    Expr Block Else? ;
For         = "for"   Identifier "in" Expr Block Else? ;
Else        = "else"  Expr ;
Break       = "break"  Expr ;
Return      = "return" Expr ;
Continue    = "continue" ;

AssignKind  =  '=' | '+=' | '-=' | '*=' | '/=' |
              '&=' | '|=' | '^=' |'<<=' |'>>=' ;

BinaryKind  = CompareOp | RangeOp | LogicOp  | BitwiseOp 
            | ShiftOp   | TermOp  | FactorOp ;
CompareOp   =  '<' | '<=' | '==' | '!=' | '>=' | '>' ;
RangeOp     = '..' | '..=' ;
LogicOp     = '&&' | '||' | '^^' ;
BitwiseOp   =  '&' | '|' | '^' ;
ShiftOp     = '<<' | '>>';
TermOp      =  '+' | '-' ;
FactorOp    =  '*' | '/' | '%' ;

UnaryKind   =  '*' | '-' | '!' | '@' | '#' | '~' ;