# Zeta Grammar
#### Version 0.0.1
## Contents
- [Todo](#todo)
- [Grammar Notation](#grammar-notation)
- [Definitions](#definitions)
+ [Lexical](#lexical)
+ [Primary](#primary)
+ [Intermediate](#intermediate)
+ [Type Expression](#type-expression)
+ [Expression](#expression)
+ [Pattern](#pattern)
+ [Statement](#statement)
## Todo
+ Generics
> e.g. `fn:<T: type, Y: T> gen_func (x: T) -> T { x + Y }`
+ `extern` label for functions and variables
> Escape name mangling system for C FFI
+ Metaprogramming syntax
> e.g. `meta for`, `emit`, `quotes`?, `meta` variables?
+ Macros?
> Something like a `meta` function with `meta` variables as parameters?
+ CTFE syntax
> e.g. `#some_func(constants)`
+ Annotation syntax
> e.g. `#[inline]`, `#[packed]`
## Grammar Notation
* `(element_a element_b etc)`
> Grouping `element_a` and `element_b` and `etc`
* `element_a | element_b | etc`
> One of `element_a` or `element_b` or `etc`
* `element+`
> One or more repetitions of `element`
* `element*`
> Zero or more repetitions of `element`
* `element~`
> Zero or one of `element`
* `element{n,N}`
> Repetitions of `element` between `n` and `N` times
* `'a'...'z'`
> Any character between and including `a` and `z`
> (`between` in terms of [numerical representation](http://www.asciitable.com/), e.g. `a` is `97` and `z` is `122`)
## Definitions
### Lexical
```ebnf
HEX_DIGIT = 'a'...'f' | 'A'...'F' | DIGIT ;
BIN_DIGIT = '0' | '1' ;
UNICODE = '\u{0}'...'\u{10FFFF}' ;
SIMPLE_ESCAPE = '\\' ('\\' | "'" | '"' | 'r' | 'n' | 't' | '0') ;
ASCII_ESCAPE = "\\a" '{' HEX_DIGIT{1,2} '}' ;
UNICODE_ESCAPE = "\\u" '{' HEX_DIGIT{1,6} '}' ;
### Primary
```ebnf
ignore = '_' ;
decimal = (DIGIT (DIGIT | ignore)* '.')~ DIGIT (DIGIT | ignore)* ('e' ('+' | '-')~ DIGIT (DIGIT | ignore)*)~ ;
hexadecimal = "0x" (HEX_DIGIT | ignore)+ ;
binary = "0b" (BIN_DIGIT | ignore)+ ;
char = "'" (UNICODE | CHAR_ESCAPE) "'" ;
constant = "nan" | "inf" ;
string = '"' (UNICODE | CHAR_ESCAPE)* '"' ;
primary = identifier | literal ;
```
### Intermediate
```ebnf
struct_field = identifier ':' type_expression ;
enum_field = identifer ('=' expression)~ ;
sum_tuple_variant = '(' type_expression (, type_expression)* ')' ;
sum_struct_variant = '[' struct_field (, struct_field)* ']' ;
sum_field = identifier (sum_tuple_variant | sum_struct_variant)~ ;
ident_chain = identifier ('.' identifier)* ;
overloadable_operator = '^' | '@' | "not" | '!' | '+' | '-'
| '+' | '-' | '*' | '/' | '%'
| "!=" | "==" | "<" | ">" | "<=" | ">="
| "and" | "or" | "xor"
| "&" | "|" | "~" | "lshift" | "rshift"
| ".." | "..."
| "->" | '.' | "[]"
| "as"
| "()"
| '='
;
function_param = pattern ':' type_expression ;
match_branch = ((identifier '=' expression) | pattern) '=>' statement ;
label = ":<" identifier '>' ;
```
### Type Expression
```ebnf
texpr_name = identifier ;
texpr_pointer = '^' type_expression ;
texpr_array = '[' expression ']' type_expression ;
texpr_tuple = '(' (type_expression (',' type_expression)*)~ ')' ;
texpr_struct = "struct" '[' (struct_field (',' struct_field)*)~ ']' ;
texpr_union = "union" '[' (struct_field (',' struct_field)*)~ ']' ;
texpr_enum = "enum" '[' (enum_field (',' enum_field)*)~ ']' ;
texpr_sum = "sum" '[' (sum_field (',' sum_field)*)~ ']' ;
texpr_function = "fn" texpr_tuple ("->" type_expression)~ ;
type_expression = texpr_name
| texpr_pointer
| texpr_array
| texpr_tuple
| texpr_struct
| texpr_union
| texpr_enum
| texpr_sum
| texpr_function
;
```
### Expression
```ebnf
expr_primary = primary ;
expr_sem_group = '(' expression ')' ;
expr_unary = ('^' | '@' | "not" | '!' | '+' | '-' | "sizeof" | "alignof" | "offsetof") expression ;
expr_binary = expression ('+' | '-' | '*' | '/' | '%' | "!=" | "==" | "<" | ">" | "<=" | ">=" | "and" | "or" | "xor" | "&" | "|" | "~" | "lshift" | "rshift" | ".." | "..." | "else") expression ;
expr_call = expression '(' (expression (',' expression)*)~ ')' ;
expr_member = expression '.' identifier ;
expr_subscript = expression '[' expression ']' ;
expr_cast = expression 'as' type_expression ;
expr_compound = (':' type_expression ':')~ '[' (compound_field (',' compound_field)*)~ ']' ;
expression = expr_primary
| expr_sem_group
| expr_unary
| expr_binary
| expr_call
| expr_member
| expr_subscript
| expr_cast
| expr_compound
| expr_block
;
```
### Pattern
```ebnf
patt_ignore = ignore ;
patt_name = ident_chain ;
patt_expr = '=' expression ;
patt_tuple = '(' patt_tuple_field (',' '...')~ (',' patt_tuple_field)* ')' ;
patt_sum = ident_chain patt_tuple ;
patt_struct = ident_chain '[' ('...' | (patt_struct_field (',' patt_struct_field)* (',' '...')~)) ']' ;
patt_else = pattern else pattern ;
patt_enums = ident_chain '{' expression '}' ;
pattern = patt_ignore
| patt_name
| patt_expr
| patt_tuple
| patt_sum
| patt_struct
| patt_else
| patt_enums
;
```
### Statement
```ebnf
stmt_block = '{' statement* expression~ '}' ;
stmt_import = "import" string ('as' identifier)~ ';' ;
stmt_export = "export" statement ;
stmt_use = "use" ident_chain ('as' identifier)~ ';' ;
stmt_type_alias = "type" identifier ':' type_expression ';' ;
stmt_struct = "struct" identifier '[' (struct_field (',' struct_field)*)~ ']' ;
stmt_union = "union" identifier '[' (struct_field (',' struct_field)*)~ ']' ;
stmt_enum = "enum" identifier '[' (enum_field (',' enum_field)*)~ ']' ;
stmt_sum = "sum" identifier '[' (sum_field (',' sum_field)*)~ ']' ;
stmt_impl = "impl" type_expression stmt_block ;
stmt_mod_assign = expression ("+=" | "-=" | "*=" | "/=" | "%=") expression ';' ;
stmt_conditional = "if" expression stmt_block ("else" "if" expression stmt_block)* ("else" stmt_block)~ ;
stmt_match = "match" expression '{' (match_branch (',' match_branch)*)~ '}' ;
stmt_for = "for" label~ pattern "in" expression stmt_block ;
stmt_while = "while" label~ expression stmt_block ;
stmt_loop = "loop" label~ stmt_block ("until" expression ';') ;
stmt_expression = expression ';' ;
statement = stmt_block
| stmt_mod
| stmt_import
| stmt_export
| stmt_use
| stmt_type_alias
| stmt_struct
| stmt_union
| stmt_enum
| stmt_sum
| stmt_impl
| stmt_function
| stmt_declaration
| stmt_assign
| stmt_mod_assign
| stmt_loop_control
| stmt_return
| stmt_conditional
| stmt_match
| stmt_for
| stmt_while
| stmt_loop
| stmt_expression
;
```
[^](#zeta-grammar)