EBNF Grammar

file

letconstlowercase_letteruppercase_letter_lowercase_letteruppercase_letterdigit_identifier?=identifier[expression].identifier=+=-=*=/=%=-!~?digitdigit_.digit_number"char"'char'stringidentifiertruefalsenil(expression){expressionbreakcontinuereturnexpressionreturn->expressionevdeclaration;statement}?block|identifier=expression[expression]=expressionmap_value,map_values|mapfn?(identifier?,parameters)expressionfunctionif?(expression)expressionifelseelseexpressionifcheck?(expression)asidentifierexpressionelseasidentifierexpressioncheckwhile?(expression)expressionwhilefor?(identifier?inexpression)expressionforprimary.identifierfield_access[expression]index(expression,arguments)callpropertieserror_handlingunary*/%factor+-term..term..termrange><>=<=comparison==!=equalityandorcombinercombinerassignementexpressiondeclarationreturn
file = { declaration } , [ return ] ;

file is referencing:

If the return statement is given, importing the file becomes valid and loads the returned values.

expression

assignement
expression = assignement ;

Items referencing expression:

expression is referencing:

assignement

identifier[expression].identifier=+=-=*=/=%=combinercombiner
assignement = identifier , { "[" , expression , "]" | "." , identifier } , { ( "=" | "+=" | "-=" | "*=" | "/=" | "%=" ) , combiner } | combiner ;

Items referencing assignement:

assignement is referencing:

Assignements assign the right of the expression to the left identifier, either directly or adds/subtracts/divides/applies the modulo operator. They evaluate to their new value, which makes this valid syntax: foo = bar += 1

combiner

equalityandor
combiner = equality , { ( "and" | "or" ) , equality } ;

Items referencing combiner:

combiner is referencing:

equality

comparison==!=
equality = comparison , { ( "==" | "!=" ) , comparison } ;

Items referencing equality:

equality is referencing:

comparison

range><>=<=
comparison = range , { ( ">" | "<" | ">=" | "<=" ) , range } ;

Items referencing comparison:

comparison is referencing:

range

term..term..term
range = term | term , ".." , term | term , ".." | ".." , term ;

Items referencing range:

range is referencing:

term

factor+-
term = factor , { ( "+" | "-" ) , factor } ;

Items referencing term:

term is referencing:

factor

unary*/%
factor = unary , { ( "*" | "/" | "%" ) , unary } ;

Items referencing factor:

factor is referencing:

unary

-!error_handling
unary = { "-" | "!" } , error_handling ;

Items referencing unary:

unary is referencing:

error_handling

~?properties
error_handling = { "~" | "?" } , properties ;

Items referencing error_handling:

error_handling is referencing:

! transforms the given value into an error value. ? unwraps an error to it's value, or returns the error if it is an error.

properties

primaryfield_accessindexcall
properties = primary , { field_access | index | call } ;

Items referencing properties:

properties is referencing:

field_access

.identifier
field_access = "." , identifier ;

Items referencing field_access:

field_access is referencing:

index

[expression]
index = "[" , expression , "]" ;

Items referencing index:

index is referencing:

call

(arguments)
call = "(" , [ arguments ] , ")" ;

Items referencing call:

call is referencing:

arguments

expression,
arguments = expression , { "," , expression } ;

Items referencing arguments:

arguments is referencing:

primary

numberstringidentifiertruefalsenil(expression)blockmapfunctionifcheckwhilefor
primary = number | string | identifier | "true" | "false" | "nil" | "(" , expression , ")" | block | map | function | if | check | while | for ;

Items referencing primary:

primary is referencing:

number

digitdigit_.digit_
number = digit , { digit | "_" } , "." , { digit | "_" }- ;

Items referencing number:

number is referencing:

string

"char"'char'
string = '"' , { char } , '"' | "'" , { char } , "'" ;

Items referencing string:

string is referencing:

Both ' and " can be used to delimit a string. They achieve the same thing.

block

{statement}?
block = "{" , { statement } , "}" , [ "?" ] ;

Items referencing block:

block is referencing:

map

|map_values|
map = "|" , [ map_values ] , "|" ;

Items referencing map:

map is referencing:

There are multiple types of syntax to define values in a map:

  1. Identifier - value (| foo = "bar" |): Assign the string "bar" to the field foo.
  2. Same-name identifiers (| foo |): Is the same as | foo = foo |.
  3. Expression - value ([2 + 3] = foo - 2): Assigns foo - 2 to 5.

map_values

map_value,
map_values = map_value , { "," , map_value } ;

Items referencing map_values:

map_values is referencing:

map_value

identifier=expression[expression]=expression
map_value = identifier | identifier , "=" , expression | "[" , expression , "]" , "=" , expression ;

Items referencing map_value:

map_value is referencing:

function

fn?(parameters)expression
function = "fn" , [ "?" ] , "(" , [ parameters ] , ")" , expression ;

Items referencing function:

function is referencing:

parameters

identifier?,
parameters = identifier , [ "?" ] , { "," , identifier , [ "?" ] } ;

Items referencing parameters:

parameters is referencing:

if

if?(expression)expressionifelseelseexpression
if = "if" , [ "?" ] , "(" , expression , ")" , expression , { "else" , "if" , "(" , expression , ")" , expression } , "else" , expression ;

Items referencing if:

if is referencing:

check

check?(expression)asidentifierexpressionelseasidentifierexpression
check = "check" , [ "?" ] , "(" , expression , ")" , [ "as" , identifier ] , expression , [ "else" , [ "as" , identifier ] , expression ] ;

Items referencing check:

check is referencing:

while

while?(expression)expression
while = "while" , [ "?" ] , "(" , expression , ")" , expression ;

Items referencing while:

while is referencing:

for

for?(identifier?inexpression)expression
for = "for" , [ "?" ] , "(" , identifier , [ "?" ] , "in" , expression , ")" , expression ;

Items referencing for:

for is referencing:

identifier

lowercase_letteruppercase_letter_lowercase_letteruppercase_letterdigit_
identifier = ( lowercase_letter | uppercase_letter | "_" ) , { lowercase_letter | uppercase_letter | digit | "_" } ;

Items referencing identifier:

identifier is referencing:

lowercase_letter

abcdefghijklmnopqrstuvwxyz
lowercase_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" ;

Items referencing lowercase_letter:

uppercase_letter

ABCDEFGHIJKLMNOPQRSTUVWXYZ
uppercase_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" ;

Items referencing uppercase_letter:

digit

1234567890
digit = "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "0" ;

Items referencing digit:

statement

expressionbreakcontinuereturnevdeclaration;
statement = ( expression | "break" | "continue" | return | ev | declaration ) , ";" ;

Items referencing statement:

statement is referencing:

return

returnexpression
return = "return" , [ expression ] ;

Items referencing return:

return is referencing:

ev

->expression
ev = "->" , [ expression ] ;

Items referencing ev:

ev is referencing:

ev makes the inner-most block that contains the ev-statement evaluate to the given expression. If no ev-statement is reached within a block, the block evaluates to nil.

declaration

letconstidentifier?=expression
declaration = ( "let" | "const" ) , identifier , [ "?" ] , "=" , expression ;

Items referencing declaration:

declaration is referencing: