urgent_stmt.exrbnf

START : <BOF>  interactive  <EOF> { $1 } ;

interactive : stmt                                    { $0 }
            | interactive_expr                        { $0 }
            ;

interactive_expr :  | interactive_expr '?' expr 'else' expr        { If(@1, $0, $2, $4) }
                    | interactive_expr 'match' match_cases         { Match(@1, $0, $2) }
                    | expr2                                        { $0 }
                    ;

ID : (<UPPER>|<LOWER>) { *$0 } ;

LET : 'let' { $0 } | 'def' { $0 } ;


bind  : bop '=' expr { (@1, *$0, $2) }
      | ID  '=' expr { (@1, $0, $2) }
      | '!' '=' expr { (@1, *$0, $2) }
      ;

binds : separated_list(',', bind) { $0 };

stmt :  LET binds                        { Let(@0, False, $1) }
      | 'rec' binds                      { Let(@0, True, $1) }
      | 'do' expr                        { Do(@0, $1) }
      | 'open'    module                 { Open(@0, $1) }
      | 'import'  module                 { Import(@0, $1) }
      | 'infixl' bop <INT>               { Infix(@0, False, *$1, int(*$2)) }
      | 'infixr' bop <INT>               { Infix(@0, True, *$1, int(*$2)) }
      | 'data' separated_list(',', cons) { Data(@0, $1) }
      ;

cons : <UPPER> slots  { Cons(@0, *$0, $1) }
     | <UPPER>        { Cons(@0, *$0, []) }
     ;

module : separated_list('.', ID)   { $0 };

slot : ID { $0 }
     | '_' { *$0 }
     ;

slots : '(' separated_list(',', slot) ')' { $1 };

expr : bind_expr                        { $0 }
     | expr '?' expr 'else' expr        { If(@1, $0, $2, $4) }
     | expr 'match' match_cases         { Match(@1, $0, $2) }
     | expr2                            { $0 }
     ;


expr2 : boolor { $0 }
      | boolor '->' expr { Fun(@1, $0, TCO($2)) }
      ;

boolor : boolor 'or' booland { Or(@1, $0, $2) }
       | booland { $0 }
        ;

booland : booland 'and' bin { And(@1, $0, $2) }
        | bin { $0 }
        ;

bind_expr     : stmt expr_cont               { In($0, $1) } ;

expr_cont : 'in' expr   { $1 }
          | bind_expr    { $0 }
          ;

match_cases : separated_list(',', match_case) { $0 } ;
match_case : pat '=>' expr                    { (@1, $0, $2) } ;

bop : | '^'  { $0 }
      | '::' { $0 }
      | <OP> { $0 }
      | <SOP> { $0 }
      | '==' { $0 }
      | '`' <UPPER> '`' { $1 }
      | '`' <LOWER> '`' { $1 }
      ;

btr  : bop call_expr       { (@0, *$0, $1) }
     | bop bind_expr       { (@0, *$0, $1) }
     ;

bin  : call_expr           { $0 }
     | call_expr list(btr) { Bin($0, $1) }
     ;

pat  : boolor { $0 } ;

call_expr : call_expr atomExpr      { Call($0, $1) }
          | atomExpr                { $0 }
          ;

atomExpr  :
          | atomExpr '.' ID                              { Field(@1, $0, $2) }
          | atomExpr '.' bop                             { Field(@1, $0, *$2) }
          | atomExpr '.' '(' separated_list(',', expr) ')' { PyCall($0, $3) }
          | atomExpr '.' '(' ')'                           { PyCall($0, []) }
          | atom                                           { $0 }
          ;

atom      : '(' ')'                                  { Tuple(@0, []) }
          | '[' ']'                                  { List(@0, []) }
          | '[' separated_list(',', expr) ']'        { List(@0, $1) }
          | '(' separated_list(',', expr) ')'        { Tuple(@0, $1) }
          | '(' bop ')'                              { Var(@0, *$1) }
          | '(' '!' ')'                              { Var(@0, *$1) }
          | <UPPER>                                  { Var(@0, *$0) }
          | <LOWER>                                  { Var(@0, *$0) }
          | '_'                                      { Var(@0, *$0) }
          | <INT>                                    { Lit(@0, int(*$0)) }
          | <FLOAT>                                  { Lit(@0, float(*$0)) }
          | <STRING>                                 { Lit(@0, DQString(*$0)) }
          | 'True'                                   { Lit(@0, True) }
          | 'False'                                  { Lit(@0, False) }
          | 'extern' <STRING>                        { Extern(@0, DQString(*$1)) }
          | '!' atom                                 { Call(Var(@0, DEREF), $1) }
          | '{' expr '}'                             { Fun(@0, Var(@0, WILDCARD), TCO($1)) }
          ;