nois.bnf

module                ::= use-stmt* statement*
                      ;
statement             ::= var-def | fn-def | trait-def | impl-def | type-def | return-stmt | break-stmt | expr
                      ;
  use-stmt            ::= PUB-KEYWORD? USE-KEYWORD use-expr
                      ;
    use-expr          ::= (NAME COLON COLON)* (use-list | NAME)
                      ;
    use-list          ::= O-BRACE (use-expr (COMMA use-expr)*)? COMMA? C-BRACE
                      ;
  var-def             ::= PUB-KEYWORD? LET-KEYWORD pattern type-annot? (EQUALS expr)?
                      ;
  fn-def              ::= PUB-KEYWORD? FN-KEYWORD NAME generics? params type-annot? block?
                      ;
    generics          ::= O-ANGLE (generic (COMMA generic)* COMMA?)? C-ANGLE
                      ;
      generic         ::= NAME (COLON type-bounds)?
                      ;
    params            ::= O-PAREN (param (COMMA param)*)? COMMA? C-PAREN
                      ;
      param           ::= pattern type-annot?
                      ;
  trait-def           ::= PUB-KEYWORD? TRAIT-KEYWORD NAME generics? block
                      ;
  impl-def            ::= IMPL-KEYWORD generics? identifier impl-for? block
                      ;
    impl-for          ::= FOR-KEYWORD identifier
                      ;
  type-def            ::= PUB-KEYWORD? TYPE-KEYWORD NAME generics? (variant-list | variant-params)?
                      ;
    variant-params    ::= O-PAREN (field-def (COMMA field-def)*)? COMMA? C-PAREN
                      ;
      field-def       ::= PUB-KEYWORD? NAME type-annot
                      ;
    variant-list      ::= O-BRACE (variant (COMMA variant)* COMMA?)? C-BRACE
                      ;
      variant         ::= NAME variant-params?
                      ;
  return-stmt         ::= RETURN-KEYWORD expr
                      ;
  break-stmt          ::= BREAK-KEYWORD
                      ;
  expr                ::= sub-expr (infix-op sub-expr)*
                      ;
    sub-expr          ::= operand postfix-op*
                      ;
      operand         ::= if-expr
                      | if-let-expr
                      | while-expr
                      | for-expr
                      | match-expr
                      | closure-expr
                      | O-PAREN expr C-PAREN
                      | list-expr
                      | string
                      | CHAR
                      | number
                      | bool
                      | identifier
                      ;
    infix-op          ::= add-op | sub-op | mult-op | div-op | exp-op | mod-op | eq-op | ne-op
                      | ge-op | le-op | gt-op | lt-op | and-op | or-op | assign-op;
      add-op          ::= PLUS;
      sub-op          ::= MINUS;
      mult-op         ::= ASTERISK;
      div-op          ::= SLASH;
      exp-op          ::= CARET;
      mod-op          ::= PERCENT;
      eq-op           ::= EQUALS EQUALS;
      ne-op           ::= EXCL EQUALS;
      ge-op           ::= C-ANGLE EQUALS;
      le-op           ::= O-ANGLE EQUALS;
      gt-op           ::= C-ANGLE;
      lt-op           ::= O-ANGLE;
      and-op          ::= AMPERSAND AMPERSAND;
      or-op           ::= PIPE PIPE;
      assign-op       ::= EQUALS;

    postfix-op        ::= method-call-op | field-access-op | call-op | unwrap-op | bind-op | await-op
                      ;                                                                                                                                                                                                                                                                                                
      method-call-op  ::= PERIOD NAME type-args? call-op
                      ;
      field-access-op ::= PERIOD NAME
                      ;
      call-op         ::= O-PAREN (arg (COMMA arg)*)? COMMA? C-PAREN
                      ;
        arg           ::= (NAME COLON)? expr
                      ;
      unwrap-op       ::= EXCL
                      ;
      bind-op         ::= QMARK
                      ;
      await-op        ::= PERIOD AWAIT-KEYWORD
                      ;
identifier            ::= (NAME COLON COLON)* NAME type-args?
                      ;
  type-args           ::= O-ANGLE (type (COMMA type)* COMMA?)? C-ANGLE
                      ;
type                  ::= type-bounds | fn-type | hole
                      ;
  type-bounds         ::= identifier (PLUS identifier)*
                      ;
  fn-type             ::= generics? fn-type-params type-annot
                      ;
    fn-type-params    ::= PIPE (type (COMMA type)* COMMA?)? PIPE
                      ;
block                 ::= O-BRACE statement* C-BRACE
                      ;
closure-expr          ::= closure-params type-annot? (block | statement)
                      ;
  closure-params      ::= PIPE (param (COMMA param)*)? COMMA? PIPE
                      ;
list-expr             ::= O-BRACKET (expr (COMMA expr)*)? COMMA? C-BRACKET
                      ;
type-annot            ::= COLON type
                      ;
if-expr               ::= IF-KEYWORD expr block (ELSE-KEYWORD block)?
                      ;
if-let-expr           ::= IF-KEYWORD LET-KEYWORD pattern EQUALS expr block (ELSE-KEYWORD block)?
                      ;
while-expr            ::= WHILE-KEYWORD expr block
                      ;
for-expr              ::= FOR-KEYWORD pattern IN-KEYWORD expr block
                      ;
match-expr            ::= MATCH-KEYWORD expr match-clauses
                      ;
  match-clauses       ::= O-BRACE match-clause* C-BRACE
                      ;
    match-clause      ::= patterns guard? block
                      ;
      patterns        ::= pattern (PIPE pattern)*
                      ;
      guard           ::= IF-KEYWORD expr
                      ;
pattern               ::= pattern-bind? pattern-expr
                      ;
  pattern-bind        ::= NAME AT
                      ;
  pattern-expr        ::= string | CHAR | number | bool | hole | NAME | con-pattern | list-pattern
                      ;
    con-pattern       ::= identifier con-pattern-params
                      ;
    con-pattern-params::= O-PAREN (field-pattern (COMMA field-pattern)*)? COMMA? C-PAREN
                      ;
      field-pattern   ::= NAME (COLON pattern)?
                      ;
    list-pattern      ::= O-BRACKET (pattern (COMMA pattern)*)? COMMA? C-BRACKET
                      ;
    hole              ::= UNDERSCORE
                      ;
number                ::= MINUS? (INT | FLOAT)
                      ;
string                ::= D-QUOTE string-part* D-QUOTE
                      ;
string-part           ::= STRING | O-BRACE expr C-BRACE
                      ;
bool                  ::= TRUE | FALSE
                      ;