single_char := ? Terminals.LetterOrDigit ?;

name := single_char { single_char };

program = { assert | vardecl | typedecl };

typedecl = 'type' name '=' type ';';

vardecl = ('var' | 'const') name [ ':' type ] ['=' expression] ';';

type = generic_type | record_type | function_signature | name;

(* Generics don't allow an empty expression list as arguments
 * As they won't be generic anymore if they don't have parameters
 *)
(* <,> is used here *)
generic_type = name '<' expression_list '>';

record_type = 'record' '(' [ record_member { ',' record_member }   ] ')';

record_member = name ':' type;

function_signature = 'fn' name '(' [ parameter { ',' parameter } ]  ')' [ '->' type ];

parameter = name ':' type;

expression = braced_expression | binop_expression | unop_expression | indexer | function | literal;

expression_list = expression { ',' expression };

braced_expression = '(' expression ')' ;

binop_expression = (expression binop expression);
unop_expression = unop expression;

literal = record | fncall | name | hexnum | number;

hexnum := '0x' {? Terminals.HexDigit ?};
number := {? Terminals.Digit ?};
fncall  = name '(' [ expression_list ] ')';
record  = 'record' '(' [expression_list] ')';

indexer          = expression (indexer_direct | indexer_indirect);
indexer_direct   = indexer_direct_t name;
indexer_direct_t = '.' | "'";
indexer_indirect = '[' expression { ',' expression } ']';

unop = '+' | '-' | '!' | '~';

(* <,> is used here *)
binop = '+' | '-' | '*' | '/' | '%' | '&' | '|' | '==' | '=' | '!='| '>=' | '<=' | '<' | '>' ;

function = function_signature body;

instruction = ';' | typedecl | vardecl | assert | return | body | if | while | break | continue | expression;

body = '{' { instruction} '}';

if = 'if' expression instruction [ 'else' instruction ];

while = 'while' expression instruction;

break = 'break' ';';
continue = 'continue' ';';
return = 'return' [ expression ] ';';
assert = 'assert' expression ';';