From 1b4a6a4ff5c54b6ac4a398a53cdcf00eba98b263 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Thu, 27 Jul 2023 09:56:00 -0400 Subject: [PATCH 001/281] Initial project organization & setup --- src/menhir-parser/Lexer.mll | 0 src/menhir-parser/Parser.mly | 0 src/menhir-parser/dune | 10 ++++++++++ 3 files changed, 10 insertions(+) create mode 100644 src/menhir-parser/Lexer.mll create mode 100644 src/menhir-parser/Parser.mly create mode 100644 src/menhir-parser/dune diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/menhir-parser/dune b/src/menhir-parser/dune new file mode 100644 index 0000000000..ba67c07f66 --- /dev/null +++ b/src/menhir-parser/dune @@ -0,0 +1,10 @@ +(library + (name hazel_menhir) + (libraries util re sexplib unionFind) + (preprocess + (pps ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) + +(ocamllex Lexer) +(menhir + (modules Parser)) + From d6a6e9590e0761bba414052940e5910a203ad641 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Thu, 27 Jul 2023 11:25:47 -0400 Subject: [PATCH 002/281] preliminary & minimal implementation of the lexer --- src/menhir-parser/Lexer.mll | 48 +++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll index e69de29bb2..899e944115 100644 --- a/src/menhir-parser/Lexer.mll +++ b/src/menhir-parser/Lexer.mll @@ -0,0 +1,48 @@ +{ +open Lexing +open Parser + +let advance_line lexbuf = + let pos = lexbuf.lex_curr_p in + let pos' = { pos with + pos_bol = lexbuf.lex_curr_pos; + pos_lnum = pos.pos_lnum + 1 + } in + lexbuf.lex_curr_p <- pos' +} + + +let float = '-'? ['0'-'9']* '.' ['0'-'9']* +let int = '-'? ['0'-'9'] ['0'-'9']* + +let newline = '\r' | '\n' | "\r\n" + +let whitespace = [' ' '\t']+ + +let identifier = ['a'-'z' 'A'-'Z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* + +rule token = + parse + | whitespace {token lexbuf } + | newline { advance_line lexbuf; token lexbuf} + | int as i { INT (int_of_string i) } + | float as f { FlOAT (float_of_string f )} + | "true" { TRUE } + | "false" { FALSE } + | "let" { LET } + | "fun" { FUN } + | "case" { CASE } + | "{" { OPEN_BRACKET } + | "}" { CLOSE_BRACKET } + | "[" { OPEN_SQUARE_BRACKET } + | "]" { CLOSE_SQUARE_BRACKET } + | "(" { OPEN_PAREN } + | ")" { CLOSE_PAREN } + | "->" { DASH_ARROW } + | "=>" { EQUAL_ARROW } + | "=" { EQUALS } + | "+" { PLUS } + | "-" { MINUS } + | identifier as i { IDENT(i) } + | eof { EOF } + | _ { raise (Failure ("Lex error: unknown char: '" ^ Lexing.lexeme lexbuf ^ "'")) } From 88f5cc78c5c9ac03c5e22c9b449b9e9aca09f423 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Thu, 27 Jul 2023 18:41:53 -0400 Subject: [PATCH 003/281] got initial version of parser to work - also added testing code --- src/menhir-parser/AST.re | 11 ++++++++ src/menhir-parser/Interface.re | 10 +++++++ src/menhir-parser/Lexer.mll | 4 ++- src/menhir-parser/Parser.mly | 50 ++++++++++++++++++++++++++++++++++ src/menhir-test/MenhirTest.re | 14 ++++++++++ src/menhir-test/dune | 5 ++++ src/menhir-test/test.hazel | 1 + 7 files changed, 94 insertions(+), 1 deletion(-) create mode 100644 src/menhir-parser/AST.re create mode 100644 src/menhir-parser/Interface.re create mode 100644 src/menhir-test/MenhirTest.re create mode 100644 src/menhir-test/dune create mode 100644 src/menhir-test/test.hazel diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re new file mode 100644 index 0000000000..154dfe10cc --- /dev/null +++ b/src/menhir-parser/AST.re @@ -0,0 +1,11 @@ +open Sexplib.Std; + +[@deriving (show({with_path: false}), sexp, yojson)] +type exp = + | Int(int) + | Float(float) + | String(string) + | Ident(string) + | BinOp(exp, string, exp) + | Let(string, exp, exp) + | Fun(string, exp, exp); diff --git a/src/menhir-parser/Interface.re b/src/menhir-parser/Interface.re new file mode 100644 index 0000000000..159e4386f8 --- /dev/null +++ b/src/menhir-parser/Interface.re @@ -0,0 +1,10 @@ +let parse = (f, s) => { + let lexbuf = Lexing.from_string(s); + let result = + try(f(Lexer.token, lexbuf)) { + | Parser.Error => raise(Failure("Parse error")) + }; + result; +}; + +let parse_program = s => parse(Parser.program, s); diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll index 899e944115..ca58a6b411 100644 --- a/src/menhir-parser/Lexer.mll +++ b/src/menhir-parser/Lexer.mll @@ -26,7 +26,7 @@ rule token = | whitespace {token lexbuf } | newline { advance_line lexbuf; token lexbuf} | int as i { INT (int_of_string i) } - | float as f { FlOAT (float_of_string f )} + | float as f { FLOAT (float_of_string f )} | "true" { TRUE } | "false" { FALSE } | "let" { LET } @@ -43,6 +43,8 @@ rule token = | "=" { EQUALS } | "+" { PLUS } | "-" { MINUS } + | "," { COMMA } + | ":" { COLON } | identifier as i { IDENT(i) } | eof { EOF } | _ { raise (Failure ("Lex error: unknown char: '" ^ Lexing.lexeme lexbuf ^ "'")) } diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index e69de29bb2..b7c4deb5ce 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -0,0 +1,50 @@ +%{ +open AST +%} + +%token IDENT +%token TRUE +%token FALSE +%token INT +%token FLOAT +%token LET +%token FUN +%token CASE +%token OPEN_BRACKET +%token CLOSE_BRACKET +%token OPEN_SQUARE_BRACKET +%token CLOSE_SQUARE_BRACKET +%token OPEN_PAREN +%token CLOSE_PAREN +%token DASH_ARROW +%token EQUAL_ARROW +%token EQUALS +%token PLUS +%token MINUS +%token COMMA +%token COLON +%token EOF + +%type exp + +%start program + +%% + +program: + | e = exp; EOF {e} + +binOp: + | PLUS {"+"} + | MINUS {"-"} + | EQUALS {"="} + +binExp: + | e1 = exp; b = binOp; e2 = exp { BinOp (e1, b, e2) } + +exp: + | i = INT { Int i } + | f = FLOAT { Float f } + (* | s = STRING { String s } *) + | i = IDENT { Ident i } + | b = binExp { b } diff --git a/src/menhir-test/MenhirTest.re b/src/menhir-test/MenhirTest.re new file mode 100644 index 0000000000..2d2f721016 --- /dev/null +++ b/src/menhir-test/MenhirTest.re @@ -0,0 +1,14 @@ +open Hazel_menhir; + +let test_file = "/home/green726/coding/hazel/src/menhir-test/test.hazel" + +let read_whole_file = filename: string => { + let ch = open_in_bin(filename); + let s = really_input_string(ch, in_channel_length(ch)); + close_in(ch); + s +} + +let file_contents = read_whole_file(test_file); + +print_endline(AST.show_exp(Interface.parse_program(file_contents))); diff --git a/src/menhir-test/dune b/src/menhir-test/dune new file mode 100644 index 0000000000..0455707c60 --- /dev/null +++ b/src/menhir-test/dune @@ -0,0 +1,5 @@ +(executable + (name MenhirTest) + (libraries base ptmap incr_dom hazel_menhir) + (preprocess + (pps ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) diff --git a/src/menhir-test/test.hazel b/src/menhir-test/test.hazel new file mode 100644 index 0000000000..d00491fd7e --- /dev/null +++ b/src/menhir-test/test.hazel @@ -0,0 +1 @@ +1 From 5cfd56a29e12216d67c599482767ae1d503ce47d Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 28 Jul 2023 22:11:21 -0400 Subject: [PATCH 004/281] drastically expanded parser, lexer, ast (reworked pats vs exps, added more binops, etc) --- src/menhir-parser/AST.re | 47 ++++++++++++++++++-- src/menhir-parser/Interface.re | 15 ++++++- src/menhir-parser/Lexer.mll | 27 +++++++++++- src/menhir-parser/Parser.mly | 79 +++++++++++++++++++++++++++++++--- src/menhir-test/test.hazel | 1 + 5 files changed, 155 insertions(+), 14 deletions(-) diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 154dfe10cc..e8a7391fe3 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -1,11 +1,50 @@ open Sexplib.Std; +[@deriving (show({with_path: false}), sexp, yojson)] +type binOp = + | Equals + | NotEqual + | Plus + | Minus + | Times + | Divide + | Power + | LessThan + | GreaterThan + | LessThanEqual + | GreaterThanEqual + | Logical_And + | Logical_Or + | Logical_Not; + + +[@deriving (show({with_path: false}), sexp, yojson)] +type typ = + | IntType + | StringType + | FloatType + | BoolType + | UnitType + | TupleType(list(typ)) + | ArrayType(typ) + | Arrow(typ, typ); + + +[@deriving (show({with_path: false}), sexp, yojson)] +type pat = + | Var(string) + | TypeAnn(pat, typ) + | TuplePat(list(pat)); + + [@deriving (show({with_path: false}), sexp, yojson)] type exp = | Int(int) | Float(float) + | Var(string) | String(string) - | Ident(string) - | BinOp(exp, string, exp) - | Let(string, exp, exp) - | Fun(string, exp, exp); + | ArrayExp(list(exp)) + | Unit + | BinExp(exp, binOp, exp) + | Let(pat, exp, exp) + | Fun(pat, exp); diff --git a/src/menhir-parser/Interface.re b/src/menhir-parser/Interface.re index 159e4386f8..c3547f375f 100644 --- a/src/menhir-parser/Interface.re +++ b/src/menhir-parser/Interface.re @@ -1,8 +1,21 @@ + +open Lexing; +let column_num = (pos : position) => { + (pos.pos_cnum - pos.pos_bol) - 1 +} + + +let string_of_pos = (pos : position) => { + let l = string_of_int(pos.pos_lnum); + let c = string_of_int(column_num(pos) + 1); + "line " ++ l ++ ", column " ++ c; +} + let parse = (f, s) => { let lexbuf = Lexing.from_string(s); let result = try(f(Lexer.token, lexbuf)) { - | Parser.Error => raise(Failure("Parse error")) + | Parser.Error => raise(Failure("Parse error at: " ++ string_of_pos(lexbuf.lex_curr_p))); }; result; }; diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll index ca58a6b411..93495cb3b7 100644 --- a/src/menhir-parser/Lexer.mll +++ b/src/menhir-parser/Lexer.mll @@ -15,6 +15,8 @@ let advance_line lexbuf = let float = '-'? ['0'-'9']* '.' ['0'-'9']* let int = '-'? ['0'-'9'] ['0'-'9']* +let string = '"' ([^ '"' '\\'] | '\\' ['"' '\\'])* '"' + let newline = '\r' | '\n' | "\r\n" let whitespace = [' ' '\t']+ @@ -27,9 +29,11 @@ rule token = | newline { advance_line lexbuf; token lexbuf} | int as i { INT (int_of_string i) } | float as f { FLOAT (float_of_string f )} + | string as s { STRING (String.sub s 1 (String.length s - 2)) } | "true" { TRUE } | "false" { FALSE } | "let" { LET } + | "in" { IN } | "fun" { FUN } | "case" { CASE } | "{" { OPEN_BRACKET } @@ -40,11 +44,30 @@ rule token = | ")" { CLOSE_PAREN } | "->" { DASH_ARROW } | "=>" { EQUAL_ARROW } - | "=" { EQUALS } + | "=" { SINGLE_EQUAL } | "+" { PLUS } - | "-" { MINUS } + | "-" { MINUS } + | "*" { TIMES } + | "/" { DIVIDE } + | "**" {POWER} + | "==" { DOUBLE_EQUAL } + | "!=" { NOT_EQUAL } + | "<" { LESS_THAN} + | "<=" { LESS_THAN_EQUAL } + | ">" { GREATER_THAN } + | ">=" { GREATER_THAN_EQUAL } + | "&&" { L_AND } + | "||" { L_OR } + | "!" { L_NOT } + | "&" { B_AND } + | "|" { B_OR } | "," { COMMA } | ":" { COLON } + | "Int" { INT_TYPE } + | "Float" { FLOAT_TYPE } + | "Bool" { BOOL_TYPE } + | "String" { STRING_TYPE } + | "()" { UNIT } | identifier as i { IDENT(i) } | eof { EOF } | _ { raise (Failure ("Lex error: unknown char: '" ^ Lexing.lexeme lexbuf ^ "'")) } diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index b7c4deb5ce..d0ce3f723a 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -3,6 +3,7 @@ open AST %} %token IDENT +%token STRING %token TRUE %token FALSE %token INT @@ -18,12 +19,39 @@ open AST %token CLOSE_PAREN %token DASH_ARROW %token EQUAL_ARROW -%token EQUALS +%token SINGLE_EQUAL + +(* bin ops *) +%token DOUBLE_EQUAL +%token NOT_EQUAL %token PLUS %token MINUS +%token DIVIDE +%token POWER +%token TIMES +%token LESS_THAN +%token LESS_THAN_EQUAL +%token GREATER_THAN +%token GREATER_THAN_EQUAL +(*logical ops*) +%token L_AND +%token L_OR +%token L_NOT +(*bitwise ops*) +%token B_AND +%token B_OR + %token COMMA %token COLON %token EOF +%token IN +%token UNIT + +(* type tokens *) +%token INT_TYPE +%token FLOAT_TYPE +%token BOOL_TYPE +%token STRING_TYPE %type exp @@ -35,16 +63,53 @@ program: | e = exp; EOF {e} binOp: - | PLUS {"+"} - | MINUS {"-"} - | EQUALS {"="} + | PLUS { Plus } + | MINUS { Minus } + | TIMES { Times } + | POWER { Power } + | DIVIDE { Divide } + | DOUBLE_EQUAL { Equals } + | NOT_EQUAL { NotEqual } + | LESS_THAN { LessThan } + | LESS_THAN_EQUAL { LessThanEqual } + | GREATER_THAN { GreaterThan } + | GREATER_THAN_EQUAL { GreaterThanEqual } + | L_AND { Logical_And } + | L_OR { Logical_Or } + | L_NOT { Logical_Not } + + binExp: - | e1 = exp; b = binOp; e2 = exp { BinOp (e1, b, e2) } + | e1 = exp; b = binOp; e2 = exp { BinExp (e1, b, e2) } + +typ: + | INT_TYPE { IntType } + | FLOAT_TYPE { FloatType } + | BOOL_TYPE { BoolType } + | STRING_TYPE { StringType } + | UNIT { UnitType } + | OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { TupleType(types) } + | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } + +pat: + | i = IDENT { Var(i) } + | t = patTuple { t } + | t = typeAnn { t } + +patTuple: + | OPEN_PAREN; pats = separated_list(COMMA, pat); CLOSE_PAREN { TuplePat(pats) } + +typeAnn: + | p = pat; COLON; t = typ { TypeAnn(p, t) } exp: | i = INT { Int i } | f = FLOAT { Float f } - (* | s = STRING { String s } *) - | i = IDENT { Ident i } + | v = IDENT { Var v } + | s = STRING { String s} | b = binExp { b } + | UNIT { Unit } + | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ArrayExp(e) } + | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } + | FUN; t = patTuple; DASH_ARROW; e1 = exp; { Fun (t, e1) } diff --git a/src/menhir-test/test.hazel b/src/menhir-test/test.hazel index d00491fd7e..746ee9dc90 100644 --- a/src/menhir-test/test.hazel +++ b/src/menhir-test/test.hazel @@ -1 +1,2 @@ +let z = fun (x: Int) -> x + 1 in 1 From 4659076557687e5ff818973ee156aa4ce4a1ab9f Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 28 Jul 2023 22:34:07 -0400 Subject: [PATCH 005/281] added cases & rules --- src/menhir-parser/AST.re | 8 ++++++-- src/menhir-parser/Lexer.mll | 5 ++++- src/menhir-parser/Parser.mly | 17 ++++++++++++++--- 3 files changed, 24 insertions(+), 6 deletions(-) diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index e8a7391fe3..d006380e99 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -36,7 +36,6 @@ type pat = | TypeAnn(pat, typ) | TuplePat(list(pat)); - [@deriving (show({with_path: false}), sexp, yojson)] type exp = | Int(int) @@ -47,4 +46,9 @@ type exp = | Unit | BinExp(exp, binOp, exp) | Let(pat, exp, exp) - | Fun(pat, exp); + | Fun(pat, exp) + | If(exp, exp, exp); + +[@deriving (show({with_path: false}), sexp, yojson)] +type rul = + | Rules(exp, list((pat, exp))); diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll index 93495cb3b7..e44656857d 100644 --- a/src/menhir-parser/Lexer.mll +++ b/src/menhir-parser/Lexer.mll @@ -36,6 +36,9 @@ rule token = | "in" { IN } | "fun" { FUN } | "case" { CASE } + | "if" { IF } + | "then" { THEN } + | "else" { ELSE } | "{" { OPEN_BRACKET } | "}" { CLOSE_BRACKET } | "[" { OPEN_SQUARE_BRACKET } @@ -60,7 +63,7 @@ rule token = | "||" { L_OR } | "!" { L_NOT } | "&" { B_AND } - | "|" { B_OR } + | "|" { TURNSTILE } | "," { COMMA } | ":" { COLON } | "Int" { INT_TYPE } diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index d0ce3f723a..ca55f82128 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -20,6 +20,7 @@ open AST %token DASH_ARROW %token EQUAL_ARROW %token SINGLE_EQUAL +%token TURNSTILE (* bin ops *) %token DOUBLE_EQUAL @@ -39,7 +40,6 @@ open AST %token L_NOT (*bitwise ops*) %token B_AND -%token B_OR %token COMMA %token COLON @@ -53,6 +53,10 @@ open AST %token BOOL_TYPE %token STRING_TYPE +%token IF +%token THEN +%token ELSE + %type exp %start program @@ -78,8 +82,6 @@ binOp: | L_OR { Logical_Or } | L_NOT { Logical_Not } - - binExp: | e1 = exp; b = binOp; e2 = exp { BinExp (e1, b, e2) } @@ -103,6 +105,12 @@ patTuple: typeAnn: | p = pat; COLON; t = typ { TypeAnn(p, t) } +rul: + | TURNSTILE; p = pat; EQUAL_ARROW; e = exp; { (p, e) } + +case: + | CASE; e = exp; l = list(rul); { Rules(e, l) } + exp: | i = INT { Int i } | f = FLOAT { Float f } @@ -113,3 +121,6 @@ exp: | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ArrayExp(e) } | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } | FUN; t = patTuple; DASH_ARROW; e1 = exp; { Fun (t, e1) } + | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (e1, e2, e3) } + + From a3c77edf1834d6b8bb2722ce3b1411ea706ffef0 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Thu, 3 Aug 2023 19:37:54 -0400 Subject: [PATCH 006/281] Expanded the patterns and changed rules/cases --- src/menhir-parser/AST.re | 14 ++++++++++---- src/menhir-parser/Lexer.mll | 2 ++ src/menhir-parser/Parser.mly | 17 +++++++++++++---- src/menhir-test/test.hazel | 11 +++++++++-- 4 files changed, 34 insertions(+), 10 deletions(-) diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index d006380e99..66c423bc29 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -32,9 +32,15 @@ type typ = [@deriving (show({with_path: false}), sexp, yojson)] type pat = + | IntPat(int) + | FloatPat(float) + | VarPat(string) + | StringPat(string) | Var(string) | TypeAnn(pat, typ) - | TuplePat(list(pat)); + | AsPat(pat, pat) + | TuplePat(list(pat)) + | ApPat(pat, pat); [@deriving (show({with_path: false}), sexp, yojson)] type exp = @@ -43,12 +49,12 @@ type exp = | Var(string) | String(string) | ArrayExp(list(exp)) + | TupleExp(list(exp)) | Unit | BinExp(exp, binOp, exp) | Let(pat, exp, exp) | Fun(pat, exp) + | CaseExp(exp, list(((pat, exp)))) + | ApExp(exp, exp) | If(exp, exp, exp); -[@deriving (show({with_path: false}), sexp, yojson)] -type rul = - | Rules(exp, list((pat, exp))); diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll index e44656857d..007d24217e 100644 --- a/src/menhir-parser/Lexer.mll +++ b/src/menhir-parser/Lexer.mll @@ -34,11 +34,13 @@ rule token = | "false" { FALSE } | "let" { LET } | "in" { IN } + | "end" { END } | "fun" { FUN } | "case" { CASE } | "if" { IF } | "then" { THEN } | "else" { ELSE } + | "as" { AS } | "{" { OPEN_BRACKET } | "}" { CLOSE_BRACKET } | "[" { OPEN_SQUARE_BRACKET } diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index ca55f82128..1a3ac11e88 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -11,6 +11,7 @@ open AST %token LET %token FUN %token CASE +%token AS %token OPEN_BRACKET %token CLOSE_BRACKET %token OPEN_SQUARE_BRACKET @@ -46,6 +47,7 @@ open AST %token EOF %token IN %token UNIT +%token END (* type tokens *) %token INT_TYPE @@ -95,9 +97,15 @@ typ: | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } pat: - | i = IDENT { Var(i) } + | i = IDENT { VarPat (i) } | t = patTuple { t } | t = typeAnn { t } + | i = INT { IntPat i } + | f = FLOAT { FloatPat f } + | s = STRING { StringPat s} + | p1 = pat; AS; p2 = pat; { AsPat(p1, p2) } + | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } + patTuple: | OPEN_PAREN; pats = separated_list(COMMA, pat); CLOSE_PAREN { TuplePat(pats) } @@ -109,7 +117,7 @@ rul: | TURNSTILE; p = pat; EQUAL_ARROW; e = exp; { (p, e) } case: - | CASE; e = exp; l = list(rul); { Rules(e, l) } + | CASE; e = exp; l = list(rul); END; { CaseExp(e, l) } exp: | i = INT { Int i } @@ -117,10 +125,11 @@ exp: | v = IDENT { Var v } | s = STRING { String s} | b = binExp { b } + | OPEN_PAREN; l = separated_list(COMMA, exp) ; CLOSE_PAREN { TupleExp(l)} + | c = case { c } | UNIT { Unit } | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ArrayExp(e) } + | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } | FUN; t = patTuple; DASH_ARROW; e1 = exp; { Fun (t, e1) } | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (e1, e2, e3) } - - diff --git a/src/menhir-test/test.hazel b/src/menhir-test/test.hazel index 746ee9dc90..362955280b 100644 --- a/src/menhir-test/test.hazel +++ b/src/menhir-test/test.hazel @@ -1,2 +1,9 @@ -let z = fun (x: Int) -> x + 1 in -1 +let z = + fun (x: Int) -> + case (x) + | 1 => 1 + | 2 => 2 + end +in + +z(1) From 77591440bcc506c4f29202290f1728f6bc065053 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 4 Aug 2023 16:02:51 -0400 Subject: [PATCH 007/281] Added arrow types & expanded test --- src/menhir-parser/AST.re | 2 +- src/menhir-parser/Parser.mly | 1 + src/menhir-test/test.hazel | 14 +++++++++----- 3 files changed, 11 insertions(+), 6 deletions(-) diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 66c423bc29..b62adf6af7 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -27,7 +27,7 @@ type typ = | UnitType | TupleType(list(typ)) | ArrayType(typ) - | Arrow(typ, typ); + | ArrowType(typ, typ); [@deriving (show({with_path: false}), sexp, yojson)] diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index 1a3ac11e88..b80adfe848 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -95,6 +95,7 @@ typ: | UNIT { UnitType } | OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { TupleType(types) } | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } + | t1 = typ; DASH_ARROW; t2 = typ { ArrowType(t1, t2) } pat: | i = IDENT { VarPat (i) } diff --git a/src/menhir-test/test.hazel b/src/menhir-test/test.hazel index 362955280b..cd85f708bc 100644 --- a/src/menhir-test/test.hazel +++ b/src/menhir-test/test.hazel @@ -1,9 +1,13 @@ -let z = - fun (x: Int) -> - case (x) - | 1 => 1 - | 2 => 2 +let intsOneElseAdd: ((Int, Int)) -> Int = + fun (x, y) -> + case (x, y) + | (1, 1) => 1 + | _ => x + y end in +let ap_and_inc: ((Int, Int) -> Int, Int) = + fun (f, x) -> f(x) + 1 +in + z(1) From a01b07c27b85a6bdfc126e0dee83125b726ddd53 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 4 Aug 2023 16:04:58 -0400 Subject: [PATCH 008/281] formatting --- src/menhir-parser/AST.re | 97 ++++++++++++++++------------------ src/menhir-parser/Interface.re | 15 +++--- src/menhir-parser/dune | 2 +- src/menhir-test/MenhirTest.re | 16 +++--- 4 files changed, 63 insertions(+), 67 deletions(-) diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index b62adf6af7..6e6424734a 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -2,59 +2,56 @@ open Sexplib.Std; [@deriving (show({with_path: false}), sexp, yojson)] type binOp = - | Equals - | NotEqual - | Plus - | Minus - | Times - | Divide - | Power - | LessThan - | GreaterThan - | LessThanEqual - | GreaterThanEqual - | Logical_And - | Logical_Or - | Logical_Not; - + | Equals + | NotEqual + | Plus + | Minus + | Times + | Divide + | Power + | LessThan + | GreaterThan + | LessThanEqual + | GreaterThanEqual + | Logical_And + | Logical_Or + | Logical_Not; [@deriving (show({with_path: false}), sexp, yojson)] -type typ = - | IntType - | StringType - | FloatType - | BoolType - | UnitType - | TupleType(list(typ)) - | ArrayType(typ) - | ArrowType(typ, typ); - +type typ = + | IntType + | StringType + | FloatType + | BoolType + | UnitType + | TupleType(list(typ)) + | ArrayType(typ) + | ArrowType(typ, typ); [@deriving (show({with_path: false}), sexp, yojson)] -type pat = - | IntPat(int) - | FloatPat(float) - | VarPat(string) - | StringPat(string) - | Var(string) - | TypeAnn(pat, typ) - | AsPat(pat, pat) - | TuplePat(list(pat)) - | ApPat(pat, pat); +type pat = + | IntPat(int) + | FloatPat(float) + | VarPat(string) + | StringPat(string) + | Var(string) + | TypeAnn(pat, typ) + | AsPat(pat, pat) + | TuplePat(list(pat)) + | ApPat(pat, pat); [@deriving (show({with_path: false}), sexp, yojson)] -type exp = - | Int(int) - | Float(float) - | Var(string) - | String(string) - | ArrayExp(list(exp)) - | TupleExp(list(exp)) - | Unit - | BinExp(exp, binOp, exp) - | Let(pat, exp, exp) - | Fun(pat, exp) - | CaseExp(exp, list(((pat, exp)))) - | ApExp(exp, exp) - | If(exp, exp, exp); - +type exp = + | Int(int) + | Float(float) + | Var(string) + | String(string) + | ArrayExp(list(exp)) + | TupleExp(list(exp)) + | Unit + | BinExp(exp, binOp, exp) + | Let(pat, exp, exp) + | Fun(pat, exp) + | CaseExp(exp, list((pat, exp))) + | ApExp(exp, exp) + | If(exp, exp, exp); diff --git a/src/menhir-parser/Interface.re b/src/menhir-parser/Interface.re index c3547f375f..dfc8cd5f97 100644 --- a/src/menhir-parser/Interface.re +++ b/src/menhir-parser/Interface.re @@ -1,21 +1,20 @@ - open Lexing; -let column_num = (pos : position) => { - (pos.pos_cnum - pos.pos_bol) - 1 -} - +let column_num = (pos: position) => { + pos.pos_cnum - pos.pos_bol - 1; +}; -let string_of_pos = (pos : position) => { +let string_of_pos = (pos: position) => { let l = string_of_int(pos.pos_lnum); let c = string_of_int(column_num(pos) + 1); "line " ++ l ++ ", column " ++ c; -} +}; let parse = (f, s) => { let lexbuf = Lexing.from_string(s); let result = try(f(Lexer.token, lexbuf)) { - | Parser.Error => raise(Failure("Parse error at: " ++ string_of_pos(lexbuf.lex_curr_p))); + | Parser.Error => + raise(Failure("Parse error at: " ++ string_of_pos(lexbuf.lex_curr_p))) }; result; }; diff --git a/src/menhir-parser/dune b/src/menhir-parser/dune index ba67c07f66..556d0d6960 100644 --- a/src/menhir-parser/dune +++ b/src/menhir-parser/dune @@ -5,6 +5,6 @@ (pps ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) (ocamllex Lexer) + (menhir (modules Parser)) - diff --git a/src/menhir-test/MenhirTest.re b/src/menhir-test/MenhirTest.re index 2d2f721016..4b8f45b554 100644 --- a/src/menhir-test/MenhirTest.re +++ b/src/menhir-test/MenhirTest.re @@ -1,13 +1,13 @@ open Hazel_menhir; -let test_file = "/home/green726/coding/hazel/src/menhir-test/test.hazel" - -let read_whole_file = filename: string => { - let ch = open_in_bin(filename); - let s = really_input_string(ch, in_channel_length(ch)); - close_in(ch); - s -} +let test_file = "/home/green726/coding/hazel/src/menhir-test/test.hazel"; + +let read_whole_file = (filename): string => { + let ch = open_in_bin(filename); + let s = really_input_string(ch, in_channel_length(ch)); + close_in(ch); + s; +}; let file_contents = read_whole_file(test_file); From c32dfb27a4fa1843268c90182e4cd15ff34ae134 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 11 Dec 2023 23:46:05 -0500 Subject: [PATCH 009/281] started working on the menhir ast -> DHExp translation - got the simple forms done --- src/haz3lcore/dune | 2 +- src/haz3lcore/dynamics/DH.re | 20 ++++++++++++++++++++ src/menhir-parser/AST.re | 1 + src/menhir-parser/Parser.mly | 2 ++ 4 files changed, 24 insertions(+), 1 deletion(-) diff --git a/src/haz3lcore/dune b/src/haz3lcore/dune index 2bfd69309d..620b5cd7b9 100644 --- a/src/haz3lcore/dune +++ b/src/haz3lcore/dune @@ -2,7 +2,7 @@ (library (name haz3lcore) - (libraries util re sexplib unionFind uuidm) + (libraries util re sexplib unionFind uuidm hazel_menhir) (js_of_ocaml (flags (:include js-of-ocaml-flags-%{profile}))) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index 01c7a31617..0aaa34e9ca 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -1,4 +1,5 @@ open Sexplib.Std; +open Hazel_menhir.AST; module rec DHExp: { [@deriving (show({with_path: false}), sexp, yojson)] @@ -307,6 +308,25 @@ module rec DHExp: { ) && i1 == i2; }; + + let rec of_menhir_ast = (exp: Hazel_menhir.AST.exp) : t => { + switch (exp) { + | Int(i) => IntLit(i) + | Float(f) => FloatLit(f) + | String(s) => StringLit(s) + | Bool(b) => BoolLit(b) + | Var(x) => BoundVar(x) + | ArrayExp(l) => ListLit(Id.mk(), 0, Unknown(SynSwitch), List.map(of_menhir_ast, l)) + | TupleExp(t) => Tuple(List.map(of_menhir_ast, t)) + | Let(p, e1, e2) => Let(DHPat.of_menhir_ast(p), of_menhir_ast(e1), of_menhir_as(e2)) + | Fun(p, e) => Fun(DHPat.of_menhir_ast(p), Unknown(SynSwitch), of_menhir_ast(e), None) + | Unit => EmptyHole(Id.mk(), 0) + | ApExp(e1, e2) => Ap(of_menhir_ast(e1), of_menhir_ast(e2)) + | BinExp(e1, op, e2) => raise(Invalid_argument("Menhir binexps -> DHExp not yet implemented")); + | If(e1, e2, e3) => raise(Invalid_argument("Menhir ifs -> DHExp not yet implemented"));//need to turn it into a case + | CaseExp(e, l) => //TODO: add in the slightly irritating translation of the list from the AST form to the DHExp form ConsistentCase(case(of_menhir_ast(e), , 0)) + } + } } and Environment: { diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 6e6424734a..dd68bb6594 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -54,4 +54,5 @@ type exp = | Fun(pat, exp) | CaseExp(exp, list((pat, exp))) | ApExp(exp, exp) + | Bool(bool) | If(exp, exp, exp); diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index b80adfe848..1c7f0cb997 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -134,3 +134,5 @@ exp: | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } | FUN; t = patTuple; DASH_ARROW; e1 = exp; { Fun (t, e1) } | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (e1, e2, e3) } + | TRUE { Bool true } + | FALSE { Bool false } From 9080650b3725518a5255059297384e8c1557ac46 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Tue, 16 Jan 2024 20:18:00 -0500 Subject: [PATCH 010/281] finished up preliminary translation --- src/haz3lcore/dynamics/DH.re | 41 ++++++++++++++++--- src/haz3lcore/dynamics/DHPat.re | 12 ++++++ src/haz3lcore/statics/TermBase.re | 48 ++++++++++++++++++++++ src/menhir-parser/AST.re | 68 +++++++++++++++++++++++-------- src/menhir-parser/Lexer.mll | 14 +++++++ src/menhir-parser/Parser.mly | 64 +++++++++++++++++++++-------- src/menhir-test/MenhirTest.re | 8 +++- src/menhir-test/dune | 2 +- 8 files changed, 217 insertions(+), 40 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index f482bd95c2..67d5bd1f20 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -53,6 +53,8 @@ module rec DHExp: { let strip_casts: t => t; let fast_equal: (t, t) => bool; + + let of_menhir_ast: Hazel_menhir.AST.exp => t; } = { [@deriving (show({with_path: false}), sexp, yojson)] type t = @@ -314,7 +316,10 @@ module rec DHExp: { && i1 == i2; }; - let rec of_menhir_ast = (exp: Hazel_menhir.AST.exp) : t => { + let rec rule_of_menhir_ast = ((pat: Hazel_menhir.AST.pat, exp: Hazel_menhir.AST.exp)) : rule => { + Rule(DHPat.of_menhir_ast(pat), of_menhir_ast(exp)); + } + and of_menhir_ast = (exp: Hazel_menhir.AST.exp) : t => { switch (exp) { | Int(i) => IntLit(i) | Float(f) => FloatLit(f) @@ -323,13 +328,39 @@ module rec DHExp: { | Var(x) => BoundVar(x) | ArrayExp(l) => ListLit(Id.mk(), 0, Unknown(SynSwitch), List.map(of_menhir_ast, l)) | TupleExp(t) => Tuple(List.map(of_menhir_ast, t)) - | Let(p, e1, e2) => Let(DHPat.of_menhir_ast(p), of_menhir_ast(e1), of_menhir_as(e2)) + | Let(p, e1, e2) => Let(DHPat.of_menhir_ast(p), of_menhir_ast(e1), of_menhir_ast(e2)) | Fun(p, e) => Fun(DHPat.of_menhir_ast(p), Unknown(SynSwitch), of_menhir_ast(e), None) | Unit => EmptyHole(Id.mk(), 0) | ApExp(e1, e2) => Ap(of_menhir_ast(e1), of_menhir_ast(e2)) - | BinExp(e1, op, e2) => raise(Invalid_argument("Menhir binexps -> DHExp not yet implemented")); - | If(e1, e2, e3) => raise(Invalid_argument("Menhir ifs -> DHExp not yet implemented"));//need to turn it into a case - | CaseExp(e, l) => //TODO: add in the slightly irritating translation of the list from the AST form to the DHExp form ConsistentCase(case(of_menhir_ast(e), , 0)) + | BinExp(e1, op, e2) => + { + switch (op) { + | IntOp(op) => BinIntOp(TermBase.UExp.int_op_of_menhir_ast(op), of_menhir_ast(e1), of_menhir_ast(e2)) + | FloatOp(op) => BinFloatOp(TermBase.UExp.float_op_of_menhir_ast(op), of_menhir_ast(e1), of_menhir_ast(e2)) + | BoolOp(op) => BinBoolOp(TermBase.UExp.bool_op_of_menhir_ast(op), of_menhir_ast(e1), of_menhir_ast(e2)) + + } + } + | If(e1, e2, e3) => { + let d_scrut = of_menhir_ast(e1) + let d1 = of_menhir_ast(e2) + let d2 = of_menhir_ast(e3) + + let d_rules = + DHExp.[Rule(BoolLit(true), d1), Rule(BoolLit(false), d2)]; + let d = DHExp.Case(d_scrut, d_rules, 0); + ConsistentCase(d); + } + + | CaseExp(e, l) => { + let d_scrut = of_menhir_ast(e) + let d_rules = List.map(rule_of_menhir_ast, l); + ConsistentCase(Case(d_scrut, d_rules, 0)) + + // raise(Invalid_argument("Menhir Case -> DHExp not yet implemented")); //TODO: add in the slightly irritating translation of the list from the AST form to the DHExp form ConsistentCase(case(of_menhir_ast(e), , 0)) + } + + // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) } } } diff --git a/src/haz3lcore/dynamics/DHPat.re b/src/haz3lcore/dynamics/DHPat.re index 0cac9b9814..45b047a729 100644 --- a/src/haz3lcore/dynamics/DHPat.re +++ b/src/haz3lcore/dynamics/DHPat.re @@ -49,3 +49,15 @@ let rec binds_var = (x: Var.t, dp: t): bool => List.fold_left((||), false, new_list); | Ap(_, _) => false }; + +let rec of_menhir_ast = (pat: Hazel_menhir.AST.pat): t => { + switch (pat) { + | IntPat(i) => IntLit(i) + | FloatPat(f) => FloatLit(f) + | VarPat(x) => Var(x) + | StringPat(s) => StringLit(s) + | TypeAnn(pat, _typ) => of_menhir_ast(pat); + | TuplePat(pats) => Tuple(List.map(of_menhir_ast, pats)) + | ApPat(pat1, pat2) => Ap(of_menhir_ast(pat1), of_menhir_ast(pat2)) + } +}; diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index a6297a3061..259ffae6f8 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -135,6 +135,10 @@ and UExp: { let int_op_to_string: op_bin_int => string; let float_op_to_string: op_bin_float => string; let string_op_to_string: op_bin_string => string; + + let int_op_of_menhir_ast: Hazel_menhir.AST.op_bin_int => op_bin_int; + let bool_op_of_menhir_ast: Hazel_menhir.AST.op_bin_bool => op_bin_bool; + let float_op_of_menhir_ast: Hazel_menhir.AST.op_bin_float => op_bin_float; } = { [@deriving (show({with_path: false}), sexp, yojson)] type op_un_bool = @@ -194,6 +198,50 @@ and UExp: { | Bool(op_bin_bool) | String(op_bin_string); + [@deriving (show({with_path: false}), sexp, yojson)] + let int_op_of_menhir_ast = (op: Hazel_menhir.AST.op_bin_int): op_bin_int => { + switch (op) { + | Plus => Plus + | Minus => Minus + | Times => Times + | Power => Power + | Divide => Divide + | LessThan => LessThan + | LessThanOrEqual => LessThanOrEqual + | GreaterThan => GreaterThan + | GreaterThanOrEqual => GreaterThanOrEqual + | Equals => Equals + | NotEquals => NotEquals + }; + }; + + [@deriving (show({with_path: false}), sexp, yojson)] + let float_op_of_menhir_ast = + (op: Hazel_menhir.AST.op_bin_float): op_bin_float => { + switch (op) { + | Plus => Plus + | Minus => Minus + | Times => Times + | Power => Power + | Divide => Divide + | LessThan => LessThan + | LessThanOrEqual => LessThanOrEqual + | GreaterThan => GreaterThan + | GreaterThanOrEqual => GreaterThanOrEqual + | Equals => Equals + | NotEquals => NotEquals + }; + }; + + [@deriving (show({with_path: false}), sexp, yojson)] + let bool_op_of_menhir_ast = + (op: Hazel_menhir.AST.op_bin_bool): op_bin_bool => { + switch (op) { + | And => And + | Or => Or + }; + }; + [@deriving (show({with_path: false}), sexp, yojson)] type term = | Invalid(string) diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index dd68bb6594..49dec55cae 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -1,21 +1,57 @@ open Sexplib.Std; + [@deriving (show({with_path: false}), sexp, yojson)] + type op_bin_float = + | Plus + | Minus + | Times + | Power + | Divide + | LessThan + | LessThanOrEqual + | GreaterThan + | GreaterThanOrEqual + | Equals + | NotEquals; + +[@deriving (show({with_path: false}), sexp, yojson)] + type op_bin_bool = + | And + | Or; + + [@deriving (show({with_path: false}), sexp, yojson)] -type binOp = - | Equals - | NotEqual - | Plus - | Minus - | Times - | Divide - | Power - | LessThan - | GreaterThan - | LessThanEqual - | GreaterThanEqual - | Logical_And - | Logical_Or - | Logical_Not; +type op_bin_int = + | Plus + | Minus + | Times + | Power + | Divide + | LessThan + | LessThanOrEqual + | GreaterThan + | GreaterThanOrEqual + | Equals + | NotEquals; + // | Equals + // | NotEqual + // | Plus + // | Minus + // | Times + // | Divide + // | Power + // | LessThan + // | GreaterThan + // | LessThanEqual + // | GreaterThanEqual + // | Logical_And + // | Logical_Or + +[@deriving (show({with_path: false}), sexp, yojson)] +type binOp = + | IntOp(op_bin_int) + | FloatOp(op_bin_float) + | BoolOp(op_bin_bool); [@deriving (show({with_path: false}), sexp, yojson)] type typ = @@ -34,9 +70,7 @@ type pat = | FloatPat(float) | VarPat(string) | StringPat(string) - | Var(string) | TypeAnn(pat, typ) - | AsPat(pat, pat) | TuplePat(list(pat)) | ApPat(pat, pat); diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll index 007d24217e..d2cbf150d5 100644 --- a/src/menhir-parser/Lexer.mll +++ b/src/menhir-parser/Lexer.mll @@ -50,6 +50,7 @@ rule token = | "->" { DASH_ARROW } | "=>" { EQUAL_ARROW } | "=" { SINGLE_EQUAL } + (* Int ops*) | "+" { PLUS } | "-" { MINUS } | "*" { TIMES } @@ -61,6 +62,19 @@ rule token = | "<=" { LESS_THAN_EQUAL } | ">" { GREATER_THAN } | ">=" { GREATER_THAN_EQUAL } + (* Float ops *) + | "+." { PLUS_FLOAT } + | "-." { MINUS_FLOAT } + | "*." { TIMES_FLOAT } + | "/." { DIVIDE_FLOAT } + | "**." {POWER_FLOAT} + | "==." { DOUBLE_EQUAL_FLOAT } + | "!=." { NOT_EQUAL_FLOAT } + | "<." { LESS_THAN_FLOAT} + | "<=." { LESS_THAN_EQUAL_FLOAT } + | ">." { GREATER_THAN_FLOAT } + | ">=." { GREATER_THAN_EQUAL_FLOAT } + (* Bool ops *) | "&&" { L_AND } | "||" { L_OR } | "!" { L_NOT } diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index 1c7f0cb997..6dd1c4d738 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -23,7 +23,7 @@ open AST %token SINGLE_EQUAL %token TURNSTILE -(* bin ops *) +(* Int ops *) %token DOUBLE_EQUAL %token NOT_EQUAL %token PLUS @@ -35,6 +35,18 @@ open AST %token LESS_THAN_EQUAL %token GREATER_THAN %token GREATER_THAN_EQUAL +(* Float ops *) +%token DOUBLE_EQUAL_FLOAT +%token NOT_EQUAL_FLOAT +%token PLUS_FLOAT +%token MINUS_FLOAT +%token DIVIDE_FLOAT +%token POWER_FLOAT +%token TIMES_FLOAT +%token LESS_THAN_FLOAT +%token LESS_THAN_EQUAL_FLOAT +%token GREATER_THAN_FLOAT +%token GREATER_THAN_EQUAL_FLOAT (*logical ops*) %token L_AND %token L_OR @@ -68,21 +80,41 @@ open AST program: | e = exp; EOF {e} +intOp: + | PLUS { IntOp(Plus) } + | MINUS { IntOp(Minus) } + | TIMES { IntOp(Times) } + | POWER { IntOp(Power) } + | DIVIDE { IntOp(Divide) } + | DOUBLE_EQUAL { IntOp(Equals) } + | NOT_EQUAL { IntOp(NotEquals) } + | LESS_THAN { IntOp(LessThan) } + | LESS_THAN_EQUAL { IntOp(LessThanOrEqual) } + | GREATER_THAN { IntOp(GreaterThan) } + | GREATER_THAN_EQUAL { IntOp(GreaterThanOrEqual) } + + +floatOp: + | PLUS_FLOAT { FloatOp(Plus) } + | MINUS_FLOAT { FloatOp(Minus) } + | TIMES_FLOAT { FloatOp(Times) } + | POWER_FLOAT { FloatOp(Power) } + | DIVIDE_FLOAT { FloatOp(Divide) } + | DOUBLE_EQUAL_FLOAT { FloatOp(Equals) } + | NOT_EQUAL_FLOAT { FloatOp(NotEquals) } + | LESS_THAN_FLOAT { FloatOp(LessThan) } + | LESS_THAN_EQUAL_FLOAT { FloatOp(LessThanOrEqual) } + | GREATER_THAN_FLOAT { FloatOp(GreaterThan) } + | GREATER_THAN_EQUAL_FLOAT { FloatOp(GreaterThanOrEqual) } + +boolOp: + | L_AND { BoolOp(And) } + | L_OR { BoolOp(Or) } + binOp: - | PLUS { Plus } - | MINUS { Minus } - | TIMES { Times } - | POWER { Power } - | DIVIDE { Divide } - | DOUBLE_EQUAL { Equals } - | NOT_EQUAL { NotEqual } - | LESS_THAN { LessThan } - | LESS_THAN_EQUAL { LessThanEqual } - | GREATER_THAN { GreaterThan } - | GREATER_THAN_EQUAL { GreaterThanEqual } - | L_AND { Logical_And } - | L_OR { Logical_Or } - | L_NOT { Logical_Not } + | i = intOp { i } + | f = floatOp { f } + | b = boolOp { b } binExp: | e1 = exp; b = binOp; e2 = exp { BinExp (e1, b, e2) } @@ -104,7 +136,7 @@ pat: | i = INT { IntPat i } | f = FLOAT { FloatPat f } | s = STRING { StringPat s} - | p1 = pat; AS; p2 = pat; { AsPat(p1, p2) } + (* | p1 = pat; AS; p2 = pat; { AsPat(p1, p2) } *) | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } diff --git a/src/menhir-test/MenhirTest.re b/src/menhir-test/MenhirTest.re index 4b8f45b554..dbca866a6b 100644 --- a/src/menhir-test/MenhirTest.re +++ b/src/menhir-test/MenhirTest.re @@ -1,4 +1,5 @@ open Hazel_menhir; +open Haz3lcore.DHExp; let test_file = "/home/green726/coding/hazel/src/menhir-test/test.hazel"; @@ -11,4 +12,9 @@ let read_whole_file = (filename): string => { let file_contents = read_whole_file(test_file); -print_endline(AST.show_exp(Interface.parse_program(file_contents))); +// print_endline(AST.show_exp(Hazel_menhir.Interface.parse_program(file_contents))); + +let prog: AST.exp = Hazel_menhir.Interface.parse_program(file_contents); + +let dhexp = of_menhir_ast(prog); +print_endline(show(dhexp)) diff --git a/src/menhir-test/dune b/src/menhir-test/dune index 0455707c60..834257af67 100644 --- a/src/menhir-test/dune +++ b/src/menhir-test/dune @@ -1,5 +1,5 @@ (executable (name MenhirTest) - (libraries base ptmap incr_dom hazel_menhir) + (libraries base ptmap incr_dom hazel_menhir haz3lcore) (preprocess (pps ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) From af03c402398ac2b79b29fb73f16aae352d48ea29 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 16 Feb 2024 12:41:52 -0500 Subject: [PATCH 011/281] Added in the cast syntax to the menhir parser; still need to test --- src/haz3lcore/dynamics/DH.re | 2 ++ src/haz3lcore/dynamics/Elaborator.re | 10 ++++++++-- src/haz3lcore/statics/TypBase.re | 19 ++++++++++++++++++ src/menhir-parser/AST.re | 1 + src/menhir-parser/Parser.mly | 1 + src/menhir-test/dune | 30 ++++++++++++++++++++++++++-- src/menhir-test/test.hazel | 6 +++--- 7 files changed, 62 insertions(+), 7 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index 67d5bd1f20..824a4ce14a 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -359,6 +359,8 @@ module rec DHExp: { // raise(Invalid_argument("Menhir Case -> DHExp not yet implemented")); //TODO: add in the slightly irritating translation of the list from the AST form to the DHExp form ConsistentCase(case(of_menhir_ast(e), , 0)) } + + | Cast(e, t1, t2) => Cast(of_menhir_ast(e), Typ.of_menhir_ast(t1), Typ.of_menhir_ast(t2)) // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) } diff --git a/src/haz3lcore/dynamics/Elaborator.re b/src/haz3lcore/dynamics/Elaborator.re index 4824a77d0a..d80601f3d7 100644 --- a/src/haz3lcore/dynamics/Elaborator.re +++ b/src/haz3lcore/dynamics/Elaborator.re @@ -341,10 +341,15 @@ and dhpat_of_upat = (m: Statics.Map.t, upat: Term.UPat.t): option(DHPat.t) => { //let dhexp_of_uexp = Core.Memo.general(~cache_size_bound=1000, dhexp_of_uexp); -let uexp_elab = (m: Statics.Map.t, uexp: Term.UExp.t): ElaborationResult.t => +let uexp_elab = (m: Statics.Map.t, uexp: Term.UExp.t): ElaborationResult.t => { + let _ = print_endline("uexp_elab"); switch (dhexp_of_uexp(m, uexp)) { - | None => DoesNotElaborate + | None => { + print_endline("dne"); + DoesNotElaborate + } | Some(d) => + print_endline(DH.DHExp.show(d)); //let d = uexp_elab_wrap_builtins(d); let ty = switch (fixed_exp_typ(m, uexp)) { @@ -353,3 +358,4 @@ let uexp_elab = (m: Statics.Map.t, uexp: Term.UExp.t): ElaborationResult.t => }; Elaborates(d, ty, Delta.empty); }; +}; diff --git a/src/haz3lcore/statics/TypBase.re b/src/haz3lcore/statics/TypBase.re index 3f614145ab..5bb6ca824d 100644 --- a/src/haz3lcore/statics/TypBase.re +++ b/src/haz3lcore/statics/TypBase.re @@ -1,6 +1,7 @@ open Sexplib.Std; open Util; open OptUtil.Syntax; +open Hazel_menhir.AST; let precedence_Prod = 1; let precedence_Arrow = 2; @@ -68,6 +69,9 @@ module rec Typ: { let sum_entry: (Constructor.t, sum_map) => option(sum_entry); let get_sum_constructors: (Ctx.t, t) => option(sum_map); let is_unknown: t => bool; + + let of_menhir_ast: Hazel_menhir.AST.typ => t; + } = { [@deriving (show({with_path: false}), sexp, yojson)] type type_provenance = @@ -424,6 +428,21 @@ module rec Typ: { | Unknown(_) => true | _ => false }; + + let rec of_menhir_ast = (typ: Hazel_menhir.AST.typ) : t => { + switch (typ) { + | IntType => Int + | FloatType => Float + | BoolType => Bool + | StringType => String + | UnitType => Prod([]) + | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) + | ArrayType(t) => List(of_menhir_ast(t)) + | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) + // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) + } + } + } and Ctx: { [@deriving (show({with_path: false}), sexp, yojson)] diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 49dec55cae..0c592ff81f 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -89,4 +89,5 @@ type exp = | CaseExp(exp, list((pat, exp))) | ApExp(exp, exp) | Bool(bool) + | Cast(exp, typ, typ) | If(exp, exp, exp); diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index 6dd1c4d738..6c7f62397a 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -166,5 +166,6 @@ exp: | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } | FUN; t = patTuple; DASH_ARROW; e1 = exp; { Fun (t, e1) } | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (e1, e2, e3) } + | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } | TRUE { Bool true } | FALSE { Bool false } diff --git a/src/menhir-test/dune b/src/menhir-test/dune index 834257af67..402b706a57 100644 --- a/src/menhir-test/dune +++ b/src/menhir-test/dune @@ -1,5 +1,31 @@ +; (executable +; (name MenhirTest) +; (libraries base ptmap incr_dom hazel_menhir haz3lcore) +; (preprocess +; (pps ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) + + (executable (name MenhirTest) - (libraries base ptmap incr_dom hazel_menhir haz3lcore) + (libraries sexplib base ptmap incr_dom hazel_menhir haz3lcore) + (modes js) + (js_of_ocaml + (flags + (:include js-of-ocaml-flags-%{profile}))) (preprocess - (pps ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) + (pps js_of_ocaml-ppx ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) + +(env + (dev + (js_of_ocaml + (flags (:standard)))) + (release + (js_of_ocaml + (flags (:standard))))) + + +(rule + (write-file js-of-ocaml-flags-dev "(:standard --debuginfo --noinline)")) + +(rule + (write-file js-of-ocaml-flags-release "(:standard)")) diff --git a/src/menhir-test/test.hazel b/src/menhir-test/test.hazel index cd85f708bc..d444ef69a4 100644 --- a/src/menhir-test/test.hazel +++ b/src/menhir-test/test.hazel @@ -6,8 +6,8 @@ let intsOneElseAdd: ((Int, Int)) -> Int = end in -let ap_and_inc: ((Int, Int) -> Int, Int) = - fun (f, x) -> f(x) + 1 +let ap_and_inc: (((Int, Int) -> Int), Int) -> Int = + fun (f, x) -> f((x, 2)) + 1 in -z(1) +ap_and_inc((intsOneElseAdd, 1)) From 951d4a282e11b5487cf1ccced7812176f7863f94 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 25 Feb 2024 10:08:32 -0600 Subject: [PATCH 012/281] Reformat --- src/haz3lcore/dynamics/DH.re | 114 ++++++++++++++++----------- src/haz3lcore/dynamics/DHPat.re | 18 ++--- src/haz3lcore/dynamics/Elaborator.re | 9 +-- src/haz3lcore/statics/TermBase.re | 5 +- src/haz3lcore/statics/TypBase.re | 28 +++---- src/menhir-parser/AST.re | 89 +++++++++++---------- src/menhir-test/MenhirTest.re | 2 +- src/menhir-test/dune | 9 ++- 8 files changed, 145 insertions(+), 129 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index 619e30f81a..266d25ad91 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -345,55 +345,73 @@ module rec DHExp: { && i1 == i2; }; - let rec rule_of_menhir_ast = ((pat: Hazel_menhir.AST.pat, exp: Hazel_menhir.AST.exp)) : rule => { - Rule(DHPat.of_menhir_ast(pat), of_menhir_ast(exp)); - } - and of_menhir_ast = (exp: Hazel_menhir.AST.exp) : t => { - switch (exp) { - | Int(i) => IntLit(i) - | Float(f) => FloatLit(f) - | String(s) => StringLit(s) - | Bool(b) => BoolLit(b) - | Var(x) => BoundVar(x) - | ArrayExp(l) => ListLit(Id.mk(), 0, Unknown(SynSwitch), List.map(of_menhir_ast, l)) - | TupleExp(t) => Tuple(List.map(of_menhir_ast, t)) - | Let(p, e1, e2) => Let(DHPat.of_menhir_ast(p), of_menhir_ast(e1), of_menhir_ast(e2)) - | Fun(p, e) => Fun(DHPat.of_menhir_ast(p), Unknown(SynSwitch), of_menhir_ast(e), None) - | Unit => EmptyHole(Id.mk(), 0) - | ApExp(e1, e2) => Ap(of_menhir_ast(e1), of_menhir_ast(e2)) - | BinExp(e1, op, e2) => - { - switch (op) { - | IntOp(op) => BinIntOp(TermBase.UExp.int_op_of_menhir_ast(op), of_menhir_ast(e1), of_menhir_ast(e2)) - | FloatOp(op) => BinFloatOp(TermBase.UExp.float_op_of_menhir_ast(op), of_menhir_ast(e1), of_menhir_ast(e2)) - | BoolOp(op) => BinBoolOp(TermBase.UExp.bool_op_of_menhir_ast(op), of_menhir_ast(e1), of_menhir_ast(e2)) - - } - } - | If(e1, e2, e3) => { - let d_scrut = of_menhir_ast(e1) - let d1 = of_menhir_ast(e2) - let d2 = of_menhir_ast(e3) - - let d_rules = - DHExp.[Rule(BoolLit(true), d1), Rule(BoolLit(false), d2)]; - let d = DHExp.Case(d_scrut, d_rules, 0); - ConsistentCase(d); - } - - | CaseExp(e, l) => { - let d_scrut = of_menhir_ast(e) - let d_rules = List.map(rule_of_menhir_ast, l); - ConsistentCase(Case(d_scrut, d_rules, 0)) - - // raise(Invalid_argument("Menhir Case -> DHExp not yet implemented")); //TODO: add in the slightly irritating translation of the list from the AST form to the DHExp form ConsistentCase(case(of_menhir_ast(e), , 0)) - } - - | Cast(e, t1, t2) => Cast(of_menhir_ast(e), Typ.of_menhir_ast(t1), Typ.of_menhir_ast(t2)) - - // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) - } + let rec rule_of_menhir_ast = + ((pat: Hazel_menhir.AST.pat, exp: Hazel_menhir.AST.exp)): rule => { + Rule(DHPat.of_menhir_ast(pat), of_menhir_ast(exp)); } + and of_menhir_ast = (exp: Hazel_menhir.AST.exp): t => { + switch (exp) { + | Int(i) => IntLit(i) + | Float(f) => FloatLit(f) + | String(s) => StringLit(s) + | Bool(b) => BoolLit(b) + | Var(x) => BoundVar(x) + | ArrayExp(l) => + ListLit(Id.mk(), 0, Unknown(SynSwitch), List.map(of_menhir_ast, l)) + | TupleExp(t) => Tuple(List.map(of_menhir_ast, t)) + | Let(p, e1, e2) => + Let(DHPat.of_menhir_ast(p), of_menhir_ast(e1), of_menhir_ast(e2)) + | Fun(p, e) => + Fun( + DHPat.of_menhir_ast(p), + Unknown(SynSwitch), + of_menhir_ast(e), + None, + ) + | Unit => EmptyHole(Id.mk(), 0) + | ApExp(e1, e2) => Ap(of_menhir_ast(e1), of_menhir_ast(e2)) + | BinExp(e1, op, e2) => + switch (op) { + | IntOp(op) => + BinIntOp( + TermBase.UExp.int_op_of_menhir_ast(op), + of_menhir_ast(e1), + of_menhir_ast(e2), + ) + | FloatOp(op) => + BinFloatOp( + TermBase.UExp.float_op_of_menhir_ast(op), + of_menhir_ast(e1), + of_menhir_ast(e2), + ) + | BoolOp(op) => + BinBoolOp( + TermBase.UExp.bool_op_of_menhir_ast(op), + of_menhir_ast(e1), + of_menhir_ast(e2), + ) + } + | If(e1, e2, e3) => + let d_scrut = of_menhir_ast(e1); + let d1 = of_menhir_ast(e2); + let d2 = of_menhir_ast(e3); + + let d_rules = + DHExp.[Rule(BoolLit(true), d1), Rule(BoolLit(false), d2)]; + let d = DHExp.Case(d_scrut, d_rules, 0); + ConsistentCase(d); + + | CaseExp(e, l) => + let d_scrut = of_menhir_ast(e); + let d_rules = List.map(rule_of_menhir_ast, l); + ConsistentCase(Case(d_scrut, d_rules, 0)); + // raise(Invalid_argument("Menhir Case -> DHExp not yet implemented")); //TODO: add in the slightly irritating translation of the list from the AST form to the DHExp form ConsistentCase(case(of_menhir_ast(e), , 0)) + + | Cast(e, t1, t2) => + Cast(of_menhir_ast(e), Typ.of_menhir_ast(t1), Typ.of_menhir_ast(t2)) + // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) + }; + }; } and Environment: { diff --git a/src/haz3lcore/dynamics/DHPat.re b/src/haz3lcore/dynamics/DHPat.re index 1315412624..ee15179883 100644 --- a/src/haz3lcore/dynamics/DHPat.re +++ b/src/haz3lcore/dynamics/DHPat.re @@ -51,15 +51,15 @@ let rec binds_var = (x: Var.t, dp: t): bool => }; let rec of_menhir_ast = (pat: Hazel_menhir.AST.pat): t => { - switch (pat) { - | IntPat(i) => IntLit(i) - | FloatPat(f) => FloatLit(f) - | VarPat(x) => Var(x) - | StringPat(s) => StringLit(s) - | TypeAnn(pat, _typ) => of_menhir_ast(pat); - | TuplePat(pats) => Tuple(List.map(of_menhir_ast, pats)) - | ApPat(pat1, pat2) => Ap(of_menhir_ast(pat1), of_menhir_ast(pat2)) - } + switch (pat) { + | IntPat(i) => IntLit(i) + | FloatPat(f) => FloatLit(f) + | VarPat(x) => Var(x) + | StringPat(s) => StringLit(s) + | TypeAnn(pat, _typ) => of_menhir_ast(pat) + | TuplePat(pats) => Tuple(List.map(of_menhir_ast, pats)) + | ApPat(pat1, pat2) => Ap(of_menhir_ast(pat1), of_menhir_ast(pat2)) + }; }; let rec bound_vars = (dp: t): list(Var.t) => diff --git a/src/haz3lcore/dynamics/Elaborator.re b/src/haz3lcore/dynamics/Elaborator.re index e5a794e730..0a1fb87b98 100644 --- a/src/haz3lcore/dynamics/Elaborator.re +++ b/src/haz3lcore/dynamics/Elaborator.re @@ -362,12 +362,11 @@ and dhpat_of_upat = (m: Statics.Map.t, upat: Term.UPat.t): option(DHPat.t) => { let uexp_elab = (m: Statics.Map.t, uexp: Term.UExp.t): ElaborationResult.t => { let _ = print_endline("uexp_elab"); switch (dhexp_of_uexp(m, uexp, false)) { - | None => { - print_endline("dne"); - DoesNotElaborate - } + | None => + print_endline("dne"); + DoesNotElaborate; | Some(d) => - print_endline(DH.DHExp.show(d)); + print_endline(DH.DHExp.show(d)); //let d = uexp_elab_wrap_builtins(d); let ty = switch (fixed_exp_typ(m, uexp)) { diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index 63ef4cab06..4b60406f75 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -284,7 +284,7 @@ and UExp: { [@deriving (show({with_path: false}), sexp, yojson)] let float_op_of_menhir_ast = - (op: Hazel_menhir.AST.op_bin_float): op_bin_float => { + (op: Hazel_menhir.AST.op_bin_float): op_bin_float => { switch (op) { | Plus => Plus | Minus => Minus @@ -301,8 +301,7 @@ and UExp: { }; [@deriving (show({with_path: false}), sexp, yojson)] - let bool_op_of_menhir_ast = - (op: Hazel_menhir.AST.op_bin_bool): op_bin_bool => { + let bool_op_of_menhir_ast = (op: Hazel_menhir.AST.op_bin_bool): op_bin_bool => { switch (op) { | And => And | Or => Or diff --git a/src/haz3lcore/statics/TypBase.re b/src/haz3lcore/statics/TypBase.re index 5a5bb38054..5ac916742f 100644 --- a/src/haz3lcore/statics/TypBase.re +++ b/src/haz3lcore/statics/TypBase.re @@ -71,7 +71,6 @@ module rec Typ: { let is_unknown: t => bool; let of_menhir_ast: Hazel_menhir.AST.typ => t; - } = { [@deriving (show({with_path: false}), sexp, yojson)] type type_provenance = @@ -429,20 +428,19 @@ module rec Typ: { | _ => false }; - let rec of_menhir_ast = (typ: Hazel_menhir.AST.typ) : t => { - switch (typ) { - | IntType => Int - | FloatType => Float - | BoolType => Bool - | StringType => String - | UnitType => Prod([]) - | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) - | ArrayType(t) => List(of_menhir_ast(t)) - | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) - // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) - } - } - + let rec of_menhir_ast = (typ: Hazel_menhir.AST.typ): t => { + switch (typ) { + | IntType => Int + | FloatType => Float + | BoolType => Bool + | StringType => String + | UnitType => Prod([]) + | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) + | ArrayType(t) => List(of_menhir_ast(t)) + | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) + // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) + }; + }; } and Ctx: { [@deriving (show({with_path: false}), sexp, yojson)] diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 0c592ff81f..9f8b5fa5d4 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -1,57 +1,56 @@ open Sexplib.Std; - [@deriving (show({with_path: false}), sexp, yojson)] - type op_bin_float = - | Plus - | Minus - | Times - | Power - | Divide - | LessThan - | LessThanOrEqual - | GreaterThan - | GreaterThanOrEqual - | Equals - | NotEquals; - [@deriving (show({with_path: false}), sexp, yojson)] - type op_bin_bool = - | And - | Or; +type op_bin_float = + | Plus + | Minus + | Times + | Power + | Divide + | LessThan + | LessThanOrEqual + | GreaterThan + | GreaterThanOrEqual + | Equals + | NotEquals; +[@deriving (show({with_path: false}), sexp, yojson)] +type op_bin_bool = + | And + | Or; [@deriving (show({with_path: false}), sexp, yojson)] type op_bin_int = - | Plus - | Minus - | Times - | Power - | Divide - | LessThan - | LessThanOrEqual - | GreaterThan - | GreaterThanOrEqual - | Equals - | NotEquals; - // | Equals - // | NotEqual - // | Plus - // | Minus - // | Times - // | Divide - // | Power - // | LessThan - // | GreaterThan - // | LessThanEqual - // | GreaterThanEqual - // | Logical_And - // | Logical_Or + | Plus + | Minus + | Times + | Power + | Divide + | LessThan + | LessThanOrEqual + | GreaterThan + | GreaterThanOrEqual + | Equals + | NotEquals; +// | Equals +// | NotEqual +// | Plus +// | Minus +// | Times +// | Divide +// | Power +// | LessThan +// | GreaterThan +// | LessThanEqual +// | GreaterThanEqual +// | Logical_And +// | Logical_Or [@deriving (show({with_path: false}), sexp, yojson)] -type binOp = - | IntOp(op_bin_int) - | FloatOp(op_bin_float) - | BoolOp(op_bin_bool); +type binOp = + | IntOp(op_bin_int) + | FloatOp(op_bin_float) + | BoolOp(op_bin_bool); [@deriving (show({with_path: false}), sexp, yojson)] type typ = diff --git a/src/menhir-test/MenhirTest.re b/src/menhir-test/MenhirTest.re index dbca866a6b..c079835707 100644 --- a/src/menhir-test/MenhirTest.re +++ b/src/menhir-test/MenhirTest.re @@ -17,4 +17,4 @@ let file_contents = read_whole_file(test_file); let prog: AST.exp = Hazel_menhir.Interface.parse_program(file_contents); let dhexp = of_menhir_ast(prog); -print_endline(show(dhexp)) +print_endline(show(dhexp)); diff --git a/src/menhir-test/dune b/src/menhir-test/dune index 402b706a57..95d01229b0 100644 --- a/src/menhir-test/dune +++ b/src/menhir-test/dune @@ -4,7 +4,6 @@ ; (preprocess ; (pps ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) - (executable (name MenhirTest) (libraries sexplib base ptmap incr_dom hazel_menhir haz3lcore) @@ -13,7 +12,12 @@ (flags (:include js-of-ocaml-flags-%{profile}))) (preprocess - (pps js_of_ocaml-ppx ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) + (pps + js_of_ocaml-ppx + ppx_let + ppx_sexp_conv + ppx_deriving.show + ppx_yojson_conv))) (env (dev @@ -23,7 +27,6 @@ (js_of_ocaml (flags (:standard))))) - (rule (write-file js-of-ocaml-flags-dev "(:standard --debuginfo --noinline)")) From 97c51878d22b21369de46f0dc66a34ac9d907994 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 25 Feb 2024 11:10:45 -0600 Subject: [PATCH 013/281] Integrate menhir tests with the haz3ltests --- src/menhir-test/MenhirTest.re | 20 ------ src/menhir-test/dune | 34 ----------- src/test/Test_Menhir.re | 91 ++++++++++++++++++++++++++++ src/test/dune | 26 +++++++- src/test/haz3ltest.re | 8 ++- src/{menhir-test => test}/test.hazel | 0 6 files changed, 122 insertions(+), 57 deletions(-) delete mode 100644 src/menhir-test/MenhirTest.re delete mode 100644 src/menhir-test/dune create mode 100644 src/test/Test_Menhir.re rename src/{menhir-test => test}/test.hazel (100%) diff --git a/src/menhir-test/MenhirTest.re b/src/menhir-test/MenhirTest.re deleted file mode 100644 index c079835707..0000000000 --- a/src/menhir-test/MenhirTest.re +++ /dev/null @@ -1,20 +0,0 @@ -open Hazel_menhir; -open Haz3lcore.DHExp; - -let test_file = "/home/green726/coding/hazel/src/menhir-test/test.hazel"; - -let read_whole_file = (filename): string => { - let ch = open_in_bin(filename); - let s = really_input_string(ch, in_channel_length(ch)); - close_in(ch); - s; -}; - -let file_contents = read_whole_file(test_file); - -// print_endline(AST.show_exp(Hazel_menhir.Interface.parse_program(file_contents))); - -let prog: AST.exp = Hazel_menhir.Interface.parse_program(file_contents); - -let dhexp = of_menhir_ast(prog); -print_endline(show(dhexp)); diff --git a/src/menhir-test/dune b/src/menhir-test/dune deleted file mode 100644 index 95d01229b0..0000000000 --- a/src/menhir-test/dune +++ /dev/null @@ -1,34 +0,0 @@ -; (executable -; (name MenhirTest) -; (libraries base ptmap incr_dom hazel_menhir haz3lcore) -; (preprocess -; (pps ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) - -(executable - (name MenhirTest) - (libraries sexplib base ptmap incr_dom hazel_menhir haz3lcore) - (modes js) - (js_of_ocaml - (flags - (:include js-of-ocaml-flags-%{profile}))) - (preprocess - (pps - js_of_ocaml-ppx - ppx_let - ppx_sexp_conv - ppx_deriving.show - ppx_yojson_conv))) - -(env - (dev - (js_of_ocaml - (flags (:standard)))) - (release - (js_of_ocaml - (flags (:standard))))) - -(rule - (write-file js-of-ocaml-flags-dev "(:standard --debuginfo --noinline)")) - -(rule - (write-file js-of-ocaml-flags-release "(:standard)")) diff --git a/src/test/Test_Menhir.re b/src/test/Test_Menhir.re new file mode 100644 index 0000000000..3f4ead4355 --- /dev/null +++ b/src/test/Test_Menhir.re @@ -0,0 +1,91 @@ +open Hazel_menhir; +open Haz3lcore.DHExp; +open Alcotest; + +let test_file = "./src/test/test.hazel"; + +let read_whole_file = (filename): string => { + let ch = open_in_bin(filename); + let s = really_input_string(ch, in_channel_length(ch)); + close_in(ch); + s; +}; + +let file_contents = read_whole_file(test_file); + +// print_endline(AST.show_exp(Hazel_menhir.Interface.parse_program(file_contents))); + +let prog: AST.exp = Hazel_menhir.Interface.parse_program(file_contents); + +let dhexp = of_menhir_ast(prog); +// print_endline(show(dhexp)); + +// let pp_string ppf x = Fmt.pf ppf "%S" x in +// testable pp_string ( = ) + +let testable_ast = testable(Fmt.using(AST.show_exp, Fmt.string), (==)); + +let parser_test = (a, expected, actual, ()) => + Alcotest.check( + testable_ast, + a, + expected, + Hazel_menhir.Interface.parse_program(actual), + ); + +let bigger_expression = + AST.Let( + TypeAnn( + VarPat("intsOneElseAdd"), + ArrowType(TupleType([TupleType([IntType, IntType])]), IntType), + ), + Fun( + TuplePat([VarPat("x"), VarPat("y")]), + CaseExp( + TupleExp([Var("x"), Var("y")]), + [ + (TuplePat([IntPat(1), IntPat(1)]), Int(1)), + (VarPat("_"), BinExp(Var("x"), IntOp(Plus), Var("y"))), + ], + ), + ), + Let( + TypeAnn( + VarPat("ap_and_inc"), + ArrowType( + TupleType([ + TupleType([ArrowType(TupleType([IntType, IntType]), IntType)]), + IntType, + ]), + IntType, + ), + ), + Fun( + TuplePat([VarPat("f"), VarPat("x")]), + BinExp( + ApExp(Var("f"), TupleExp([Var("x"), Int(2)])), + IntOp(Plus), + Int(1), + ), + ), + ApExp(Var("ap_and_inc"), TupleExp([Var("intsOneElseAdd"), Int(1)])), + ), + ); + +let tests = [ + test_case( + "Integer Literal", + `Quick, + parser_test("Same Integer", Int(7), "7"), + ), + test_case( + "String Literal", + `Quick, + parser_test("Same String", String("Hello World"), "\"Hello World\""), + ), + test_case( + "Bigger expression", + `Quick, + parser_test("test.hazel contents", bigger_expression, file_contents), + ), +]; diff --git a/src/test/dune b/src/test/dune index 8ab5bfe0af..a0298d8ceb 100644 --- a/src/test/dune +++ b/src/test/dune @@ -2,7 +2,29 @@ (test (name haz3ltest) - (libraries haz3lcore alcotest) + (libraries haz3lcore alcotest sexplib base ptmap incr_dom hazel_menhir) (modes js) + (js_of_ocaml + (flags + (:include js-of-ocaml-flags-%{profile}))) (preprocess - (pps js_of_ocaml-ppx))) + (pps + js_of_ocaml-ppx + ppx_let + ppx_sexp_conv + ppx_deriving.show + ppx_yojson_conv))) + +(env + (dev + (js_of_ocaml + (flags (:standard)))) + (release + (js_of_ocaml + (flags (:standard))))) + +(rule + (write-file js-of-ocaml-flags-dev "(:standard --debuginfo --noinline)")) + +(rule + (write-file js-of-ocaml-flags-release "(:standard)")) diff --git a/src/test/haz3ltest.re b/src/test/haz3ltest.re index bc38590103..7f0f64b8fe 100644 --- a/src/test/haz3ltest.re +++ b/src/test/haz3ltest.re @@ -1,3 +1,9 @@ open Alcotest; -run("Dynamics", [("Elaboration", Test_Elaboration.elaboration_tests)]); +run( + "Dynamics", + [ + ("Elaboration", Test_Elaboration.elaboration_tests), + ("Parser", Test_Menhir.tests) // TODO This should probably be separated at the library level and not under dynamics + ], +); diff --git a/src/menhir-test/test.hazel b/src/test/test.hazel similarity index 100% rename from src/menhir-test/test.hazel rename to src/test/test.hazel From 3bc42275f75a76c44a6fef215d78ad8332a61160 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 25 Feb 2024 11:50:24 -0600 Subject: [PATCH 014/281] Try failing test --- src/test/Test_Menhir.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/Test_Menhir.re b/src/test/Test_Menhir.re index 3f4ead4355..d38be17df8 100644 --- a/src/test/Test_Menhir.re +++ b/src/test/Test_Menhir.re @@ -76,7 +76,7 @@ let tests = [ test_case( "Integer Literal", `Quick, - parser_test("Same Integer", Int(7), "7"), + parser_test("Same Integer", Int(7), "8"), ), test_case( "String Literal", From db3b918ac734a01da97245a92e236a6d4119ca03 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Tue, 12 Mar 2024 11:10:10 -0400 Subject: [PATCH 015/281] fixed the menhir parser test for integer literal --- src/test/Test_Menhir.re | 2 +- src/test/dune | 11 ++++++++++- src/test/haz3ltest.re | 6 ++++-- 3 files changed, 15 insertions(+), 4 deletions(-) diff --git a/src/test/Test_Menhir.re b/src/test/Test_Menhir.re index d38be17df8..0582d0be4c 100644 --- a/src/test/Test_Menhir.re +++ b/src/test/Test_Menhir.re @@ -76,7 +76,7 @@ let tests = [ test_case( "Integer Literal", `Quick, - parser_test("Same Integer", Int(7), "8"), + parser_test("Same Integer", Int(8), "8"), ), test_case( "String Literal", diff --git a/src/test/dune b/src/test/dune index 08108334fc..0639bdc35f 100644 --- a/src/test/dune +++ b/src/test/dune @@ -2,7 +2,16 @@ (test (name haz3ltest) - (libraries haz3lcore alcotest sexplib base ptmap incr_dom hazel_menhir junit junit_alcotest) + (libraries + haz3lcore + alcotest + sexplib + base + ptmap + incr_dom + hazel_menhir + junit + junit_alcotest) (modes js) (js_of_ocaml (flags diff --git a/src/test/haz3ltest.re b/src/test/haz3ltest.re index 23733ff282..73ab90e875 100644 --- a/src/test/haz3ltest.re +++ b/src/test/haz3ltest.re @@ -1,10 +1,12 @@ open Junit_alcotest; - let (suite, _) = run_and_report( ~and_exit=false, "Dynamics", - [("Elaboration", Test_Elaboration.elaboration_tests), ("Parser", Test_Menhir.tests)], + [ + ("Elaboration", Test_Elaboration.elaboration_tests), + ("Parser", Test_Menhir.tests), + ], ); Junit.to_file(Junit.make([suite]), "junit_tests.xml"); From cdfc8ad53185ec34f4d8ad3c09f605d70477c994 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Tue, 12 Mar 2024 13:46:54 -0400 Subject: [PATCH 016/281] fixing some bugs with the functions expressions in the menhir parser --- src/menhir-parser/AST.re | 13 ------------- src/menhir-parser/Parser.mly | 2 +- src/test/Test_Elaboration.re | 34 ++++++++++++++++++++++++++++++++++ 3 files changed, 35 insertions(+), 14 deletions(-) diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 9f8b5fa5d4..021cbb0292 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -32,19 +32,6 @@ type op_bin_int = | GreaterThanOrEqual | Equals | NotEquals; -// | Equals -// | NotEqual -// | Plus -// | Minus -// | Times -// | Divide -// | Power -// | LessThan -// | GreaterThan -// | LessThanEqual -// | GreaterThanEqual -// | Logical_And -// | Logical_Or [@deriving (show({with_path: false}), sexp, yojson)] type binOp = diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index 6c7f62397a..e0ceb5e63c 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -164,7 +164,7 @@ exp: | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ArrayExp(e) } | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } - | FUN; t = patTuple; DASH_ARROW; e1 = exp; { Fun (t, e1) } + | FUN; t = pat; DASH_ARROW; e1 = exp; { Fun (t, e1) } | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (e1, e2, e3) } | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } | TRUE { Bool true } diff --git a/src/test/Test_Elaboration.re b/src/test/Test_Elaboration.re index 2e20c1e869..867d47ffc1 100644 --- a/src/test/Test_Elaboration.re +++ b/src/test/Test_Elaboration.re @@ -1,5 +1,6 @@ open Alcotest; open Haz3lcore; +// open Hazel_menhir; let dhexp_eq = (d1: option(DHExp.t), d2: option(DHExp.t)): bool => switch (d1, d2) { @@ -277,6 +278,38 @@ let let_fun = () => dhexp_of_uexp(u9), ); +let str10 = " +let f : Int -> Int = + fun x -> + 1 + x + in +55"; +let d10: DHExp.t = + Let( + Var("f"), + FixF( + "f", + Arrow(Int, Int), + Fun( + Var("x"), + Int, + BinIntOp(Plus, IntLit(1), BoundVar("x")), + Some("f"), + ), + ), + IntLit(55), + ); +let let_fun_menhir = () => + alco_check( + "Let expression for function which wraps a fix point constructor around the function (str elaborated using the menhir parser)", + Some(d10), + Some( + Haz3lcore.DHExp.of_menhir_ast( + Hazel_menhir.Interface.parse_program(str10), + ), + ), + ); + let elaboration_tests = [ test_case("Single integer", `Quick, single_integer), test_case("Empty hole", `Quick, empty_hole), @@ -287,4 +320,5 @@ let elaboration_tests = [ test_case("Application of function on free variable", `Quick, ap_fun), test_case("Inconsistent case statement", `Quick, inconsistent_case), test_case("Let expression for a function", `Quick, let_fun), + test_case("Let expression for a function (menhir)", `Quick, let_fun_menhir), ]; From d3a5995f9fe30ab16a1ba7917242d2f422387b5d Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Wed, 20 Mar 2024 12:53:04 -0400 Subject: [PATCH 017/281] changed the elaborator test to start adding in Menhir tests - some issues with the output from the menhir -> DHExp --- src/test/Test_Elaboration.re | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test/Test_Elaboration.re b/src/test/Test_Elaboration.re index 867d47ffc1..d9db313dc1 100644 --- a/src/test/Test_Elaboration.re +++ b/src/test/Test_Elaboration.re @@ -299,6 +299,7 @@ let d10: DHExp.t = ), IntLit(55), ); + let let_fun_menhir = () => alco_check( "Let expression for function which wraps a fix point constructor around the function (str elaborated using the menhir parser)", From 8ecd025301c5cb8023439ab888f2c6a3572d522a Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Tue, 2 Apr 2024 12:33:35 -0400 Subject: [PATCH 018/281] modified the menhir parser to have manual annotations for fun exp types & changed tests to reflect this --- src/haz3lcore/dynamics/DH.re | 15 ++++- src/menhir-parser/AST.re | 2 +- src/menhir-parser/Parser.mly | 2 +- src/test/Test_Elaboration.re | 15 +---- src/test/Test_Menhir.re | 107 ++++++++++++++++++----------------- 5 files changed, 74 insertions(+), 67 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index 266d25ad91..ce934ff798 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -361,13 +361,24 @@ module rec DHExp: { | TupleExp(t) => Tuple(List.map(of_menhir_ast, t)) | Let(p, e1, e2) => Let(DHPat.of_menhir_ast(p), of_menhir_ast(e1), of_menhir_ast(e2)) - | Fun(p, e) => + | Fun(t, p, e) => Fun( DHPat.of_menhir_ast(p), - Unknown(SynSwitch), + Typ.of_menhir_ast(t), of_menhir_ast(e), None, ) + // switch (p) { + // | TypeAnn(p, t) => + // Fun( + // DHPat.of_menhir_ast(p), + // Typ.of_menhir_ast(t), + // of_menhir_ast(e), + // None, + // ) + // | _ => + // raise(Invalid_argument("Menhir fun parsed without an annotated pat")) + // } | Unit => EmptyHole(Id.mk(), 0) | ApExp(e1, e2) => Ap(of_menhir_ast(e1), of_menhir_ast(e2)) | BinExp(e1, op, e2) => diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 021cbb0292..51b172a929 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -71,7 +71,7 @@ type exp = | Unit | BinExp(exp, binOp, exp) | Let(pat, exp, exp) - | Fun(pat, exp) + | Fun(typ, pat, exp) | CaseExp(exp, list((pat, exp))) | ApExp(exp, exp) | Bool(bool) diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index e0ceb5e63c..3b877f862e 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -164,7 +164,7 @@ exp: | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ArrayExp(e) } | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } - | FUN; t = pat; DASH_ARROW; e1 = exp; { Fun (t, e1) } + | FUN; COLON; t = typ; p = pat; DASH_ARROW; e1 = exp; { Fun (t, p, e1) } | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (e1, e2, e3) } | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } | TRUE { Bool true } diff --git a/src/test/Test_Elaboration.re b/src/test/Test_Elaboration.re index d9db313dc1..1ae26b3851 100644 --- a/src/test/Test_Elaboration.re +++ b/src/test/Test_Elaboration.re @@ -280,29 +280,20 @@ let let_fun = () => let str10 = " let f : Int -> Int = - fun x -> + fun: Int x -> 1 + x in 55"; let d10: DHExp.t = Let( Var("f"), - FixF( - "f", - Arrow(Int, Int), - Fun( - Var("x"), - Int, - BinIntOp(Plus, IntLit(1), BoundVar("x")), - Some("f"), - ), - ), + Fun(Var("x"), Int, BinIntOp(Plus, IntLit(1), BoundVar("x")), None), IntLit(55), ); let let_fun_menhir = () => alco_check( - "Let expression for function which wraps a fix point constructor around the function (str elaborated using the menhir parser)", + "Let expression for function (str elaborated using the menhir parser)", Some(d10), Some( Haz3lcore.DHExp.of_menhir_ast( diff --git a/src/test/Test_Menhir.re b/src/test/Test_Menhir.re index 0582d0be4c..fdd584b8b4 100644 --- a/src/test/Test_Menhir.re +++ b/src/test/Test_Menhir.re @@ -1,5 +1,5 @@ open Hazel_menhir; -open Haz3lcore.DHExp; +// open Haz3lcore.DHExp; open Alcotest; let test_file = "./src/test/test.hazel"; @@ -15,9 +15,9 @@ let file_contents = read_whole_file(test_file); // print_endline(AST.show_exp(Hazel_menhir.Interface.parse_program(file_contents))); -let prog: AST.exp = Hazel_menhir.Interface.parse_program(file_contents); +// let prog: AST.exp = Hazel_menhir.Interface.parse_program(file_contents); -let dhexp = of_menhir_ast(prog); +// let dhexp = of_menhir_ast(prog); // print_endline(show(dhexp)); // let pp_string ppf x = Fmt.pf ppf "%S" x in @@ -33,44 +33,48 @@ let parser_test = (a, expected, actual, ()) => Hazel_menhir.Interface.parse_program(actual), ); -let bigger_expression = - AST.Let( - TypeAnn( - VarPat("intsOneElseAdd"), - ArrowType(TupleType([TupleType([IntType, IntType])]), IntType), - ), - Fun( - TuplePat([VarPat("x"), VarPat("y")]), - CaseExp( - TupleExp([Var("x"), Var("y")]), - [ - (TuplePat([IntPat(1), IntPat(1)]), Int(1)), - (VarPat("_"), BinExp(Var("x"), IntOp(Plus), Var("y"))), - ], - ), - ), - Let( - TypeAnn( - VarPat("ap_and_inc"), - ArrowType( - TupleType([ - TupleType([ArrowType(TupleType([IntType, IntType]), IntType)]), - IntType, - ]), - IntType, - ), - ), - Fun( - TuplePat([VarPat("f"), VarPat("x")]), - BinExp( - ApExp(Var("f"), TupleExp([Var("x"), Int(2)])), - IntOp(Plus), - Int(1), - ), - ), - ApExp(Var("ap_and_inc"), TupleExp([Var("intsOneElseAdd"), Int(1)])), - ), - ); +// let bigger_expression = +// AST.Let( +// TypeAnn( +// VarPat("intsOneElseAdd"), +// ArrowType(TupleType([TupleType([IntType, IntType])]), IntType), +// ), +// Fun( +// TuplePat([VarPat("x"), VarPat("y")]), +// CaseExp( +// TupleExp([Var("x"), Var("y")]), +// [ +// (TuplePat([IntPat(1), IntPat(1)]), Int(1)), +// (VarPat("_"), BinExp(Var("x"), IntOp(Plus), Var("y"))), +// ], +// ), +// ), +// Let( +// TypeAnn( +// VarPat("ap_and_inc"), +// ArrowType( +// TupleType([ +// TupleType([ArrowType(TupleType([IntType, IntType]), IntType)]), +// IntType, +// ]), +// IntType, +// ), +// ), +// Fun( +// TuplePat([VarPat("f"), VarPat("x")]), +// BinExp( +// ApExp(Var("f"), TupleExp([Var("x"), Int(2)])), +// IntOp(Plus), +// Int(1), +// ), +// ), +// ApExp(Var("ap_and_inc"), TupleExp([Var("intsOneElseAdd"), Int(1)])), +// ), +// ); + +let fun_exp = AST.Fun(IntType, VarPat("x"), Var("x")); + +let fun_str = "fun: Int x -> x"; let tests = [ test_case( @@ -78,14 +82,15 @@ let tests = [ `Quick, parser_test("Same Integer", Int(8), "8"), ), - test_case( - "String Literal", - `Quick, - parser_test("Same String", String("Hello World"), "\"Hello World\""), - ), - test_case( - "Bigger expression", - `Quick, - parser_test("test.hazel contents", bigger_expression, file_contents), - ), + test_case("Fun", `Quick, parser_test("Fun", fun_exp, fun_str)), + // test_case( + // "String Literal", + // `Quick, + // parser_test("Same String", String("Hello World"), "\"Hello World\""), + // ), + // test_case( + // "Bigger expression", + // `Quick, + // parser_test("test.hazel contents", bigger_expression, file_contents), + // ), ]; From 16b7e4abcaa8c102ab570084f671ef4eda5b7dd2 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Wed, 3 Apr 2024 19:07:54 -0400 Subject: [PATCH 019/281] added support for the holes, closures, hole ids, and free vars --- src/haz3lcore/dynamics/DH.re | 109 ++++++++++++++++++++++------------- src/menhir-parser/AST.re | 7 ++- src/menhir-parser/Lexer.mll | 2 + src/menhir-parser/Parser.mly | 19 +++++- src/test/Test_Elaboration.re | 79 +++++++++++++++++++++---- src/test/Test_Menhir.re | 2 +- 6 files changed, 161 insertions(+), 57 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index ce934ff798..a84f859eca 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -61,7 +61,7 @@ module rec DHExp: { let fast_equal: (t, t) => bool; - let of_menhir_ast: Hazel_menhir.AST.exp => t; + let of_menhir_ast: (Hazel_menhir.AST.exp, bool => Uuidm.t) => t; } = { [@deriving (show({with_path: false}), sexp, yojson)] type t = @@ -346,66 +346,86 @@ module rec DHExp: { }; let rec rule_of_menhir_ast = - ((pat: Hazel_menhir.AST.pat, exp: Hazel_menhir.AST.exp)): rule => { - Rule(DHPat.of_menhir_ast(pat), of_menhir_ast(exp)); + ( + (pat: Hazel_menhir.AST.pat, exp: Hazel_menhir.AST.exp), + getId: bool => Id.t, + ) + : rule => { + Rule(DHPat.of_menhir_ast(pat), of_menhir_ast(exp, getId)); } - and of_menhir_ast = (exp: Hazel_menhir.AST.exp): t => { + //whenever we assign a hole an id, make sure to increment the idIndex value + and of_menhir_ast = (exp: Hazel_menhir.AST.exp, getId: bool => Id.t): t => { + let of_menhir_ast_noid = of_menhir_ast(_, getId); + let getId_all_args = getId; + // let getId_no_inc = () => getId(false); + let getId = () => getId(true); + switch (exp) { | Int(i) => IntLit(i) | Float(f) => FloatLit(f) | String(s) => StringLit(s) | Bool(b) => BoolLit(b) | Var(x) => BoundVar(x) + | FreeVar(x) => FreeVar(getId_all_args(false), 0, x) | ArrayExp(l) => - ListLit(Id.mk(), 0, Unknown(SynSwitch), List.map(of_menhir_ast, l)) - | TupleExp(t) => Tuple(List.map(of_menhir_ast, t)) + ListLit( + Id.mk(), + 0, + Unknown(SynSwitch), + List.map(of_menhir_ast_noid, l), + ) + | TupleExp(t) => Tuple(List.map(of_menhir_ast_noid, t)) | Let(p, e1, e2) => - Let(DHPat.of_menhir_ast(p), of_menhir_ast(e1), of_menhir_ast(e2)) - | Fun(t, p, e) => - Fun( + Let( DHPat.of_menhir_ast(p), - Typ.of_menhir_ast(t), - of_menhir_ast(e), - None, + of_menhir_ast_noid(e1), + of_menhir_ast_noid(e2), ) - // switch (p) { - // | TypeAnn(p, t) => - // Fun( - // DHPat.of_menhir_ast(p), - // Typ.of_menhir_ast(t), - // of_menhir_ast(e), - // None, - // ) - // | _ => - // raise(Invalid_argument("Menhir fun parsed without an annotated pat")) - // } - | Unit => EmptyHole(Id.mk(), 0) - | ApExp(e1, e2) => Ap(of_menhir_ast(e1), of_menhir_ast(e2)) + | Fun(t, p, e, name_opt) => + switch (name_opt) { + | Some(name_str) => + Fun( + DHPat.of_menhir_ast(p), + Typ.of_menhir_ast(t), + of_menhir_ast_noid(e), + Some(name_str), + ) + | None => + Fun( + DHPat.of_menhir_ast(p), + Typ.of_menhir_ast(t), + of_menhir_ast_noid(e), + None, + ) + } + | FixF(name, t, f) => + FixF(name, Typ.of_menhir_ast(t), of_menhir_ast_noid(f)) + | ApExp(e1, e2) => Ap(of_menhir_ast_noid(e1), of_menhir_ast_noid(e2)) | BinExp(e1, op, e2) => switch (op) { | IntOp(op) => BinIntOp( TermBase.UExp.int_op_of_menhir_ast(op), - of_menhir_ast(e1), - of_menhir_ast(e2), + of_menhir_ast_noid(e1), + of_menhir_ast_noid(e2), ) | FloatOp(op) => BinFloatOp( TermBase.UExp.float_op_of_menhir_ast(op), - of_menhir_ast(e1), - of_menhir_ast(e2), + of_menhir_ast_noid(e1), + of_menhir_ast_noid(e2), ) | BoolOp(op) => BinBoolOp( TermBase.UExp.bool_op_of_menhir_ast(op), - of_menhir_ast(e1), - of_menhir_ast(e2), + of_menhir_ast_noid(e1), + of_menhir_ast_noid(e2), ) } | If(e1, e2, e3) => - let d_scrut = of_menhir_ast(e1); - let d1 = of_menhir_ast(e2); - let d2 = of_menhir_ast(e3); + let d_scrut = of_menhir_ast_noid(e1); + let d1 = of_menhir_ast_noid(e2); + let d2 = of_menhir_ast_noid(e3); let d_rules = DHExp.[Rule(BoolLit(true), d1), Rule(BoolLit(false), d2)]; @@ -413,13 +433,24 @@ module rec DHExp: { ConsistentCase(d); | CaseExp(e, l) => - let d_scrut = of_menhir_ast(e); - let d_rules = List.map(rule_of_menhir_ast, l); + let d_scrut = of_menhir_ast_noid(e); + let d_rules = List.map(rule_of_menhir_ast(_, getId_all_args), l); ConsistentCase(Case(d_scrut, d_rules, 0)); - // raise(Invalid_argument("Menhir Case -> DHExp not yet implemented")); //TODO: add in the slightly irritating translation of the list from the AST form to the DHExp form ConsistentCase(case(of_menhir_ast(e), , 0)) - | Cast(e, t1, t2) => - Cast(of_menhir_ast(e), Typ.of_menhir_ast(t1), Typ.of_menhir_ast(t2)) + Cast( + of_menhir_ast_noid(e), + Typ.of_menhir_ast(t1), + Typ.of_menhir_ast(t2), + ) + | EmptyHole => EmptyHole(getId(), 0) + | NonEmptyHole(e) => + let id = getId(); + NonEmptyHole( + ErrStatus.HoleReason.TypeInconsistent, + id, + 0, + of_menhir_ast_noid(e), + ); // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) }; }; diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 51b172a929..4993b873f0 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -65,15 +65,18 @@ type exp = | Int(int) | Float(float) | Var(string) + | FreeVar(string) | String(string) | ArrayExp(list(exp)) | TupleExp(list(exp)) - | Unit | BinExp(exp, binOp, exp) | Let(pat, exp, exp) - | Fun(typ, pat, exp) + | Fun(typ, pat, exp, option(string)) + | FixF(string, typ, exp) | CaseExp(exp, list((pat, exp))) | ApExp(exp, exp) | Bool(bool) | Cast(exp, typ, typ) + | NonEmptyHole(exp) + | EmptyHole | If(exp, exp, exp); diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll index d2cbf150d5..18e3190b4a 100644 --- a/src/menhir-parser/Lexer.mll +++ b/src/menhir-parser/Lexer.mll @@ -87,6 +87,8 @@ rule token = | "Bool" { BOOL_TYPE } | "String" { STRING_TYPE } | "()" { UNIT } + | "_FIX" {FIX} + | "_FREE" {FREE} | identifier as i { IDENT(i) } | eof { EOF } | _ { raise (Failure ("Lex error: unknown char: '" ^ Lexing.lexeme lexbuf ^ "'")) } diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index 3b877f862e..e4f3fbd254 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -2,6 +2,8 @@ open AST %} +%token FREE +%token FIX %token IDENT %token STRING %token TRUE @@ -129,8 +131,11 @@ typ: | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } | t1 = typ; DASH_ARROW; t2 = typ { ArrowType(t1, t2) } -pat: +varPat: | i = IDENT { VarPat (i) } + +pat: + | p = varPat {p} | t = patTuple { t } | t = typeAnn { t } | i = INT { IntPat i } @@ -152,20 +157,28 @@ rul: case: | CASE; e = exp; l = list(rul); END; { CaseExp(e, l) } +funExp: + | FUN; COLON; t = typ; p = pat; DASH_ARROW; e1 = exp; { Fun (t, p, e1, None) } + | FUN; COLON; t = typ; p = pat; DASH_ARROW; e1 = exp; name = IDENT { Fun (t, p, e1, Some(name)) } + + exp: | i = INT { Int i } | f = FLOAT { Float f } | v = IDENT { Var v } + | FREE; v = IDENT { FreeVar v } | s = STRING { String s} | b = binExp { b } | OPEN_PAREN; l = separated_list(COMMA, exp) ; CLOSE_PAREN { TupleExp(l)} | c = case { c } - | UNIT { Unit } | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ArrayExp(e) } | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } - | FUN; COLON; t = typ; p = pat; DASH_ARROW; e1 = exp; { Fun (t, p, e1) } | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (e1, e2, e3) } | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } | TRUE { Bool true } + | FIX; s = IDENT; t = typ; f = funExp { FixF(s, t, f) } + | f = funExp {f} | FALSE { Bool false } + | OPEN_PAREN; e = exp; CLOSE_PAREN { NonEmptyHole(e) } + | UNIT { EmptyHole } diff --git a/src/test/Test_Elaboration.re b/src/test/Test_Elaboration.re index 1ae26b3851..d781ea7e3e 100644 --- a/src/test/Test_Elaboration.re +++ b/src/test/Test_Elaboration.re @@ -20,6 +20,24 @@ let dhexp_typ = testable(Fmt.using(dhexp_print, Fmt.string), dhexp_eq); let ids = List.init(12, _ => Id.mk()); let id_at = x => x |> List.nth(ids); + +//Starts at 0 +let get_id_menhir_closure = (id_index: int) => { + let id_index = ref(id_index - 1); + (inc: bool) => { + print_endline( + "get id inc: " + ++ string_of_bool(inc) + ++ " " + ++ string_of_int(id_index^), + ); + if (inc) { + id_index := id_index^ + 1; + }; + id_at(id_index^); + }; +}; + let mk_map = CoreSettings.on |> Interface.Statics.mk_map; let dhexp_of_uexp = u => Elaborator.dhexp_of_uexp(mk_map(u), u, false); let alco_check = dhexp_typ |> Alcotest.check; @@ -280,26 +298,61 @@ let let_fun = () => let str10 = " let f : Int -> Int = - fun: Int x -> + _FIX f Int -> Int fun: Int x -> 1 + x + f in 55"; -let d10: DHExp.t = - Let( - Var("f"), - Fun(Var("x"), Int, BinIntOp(Plus, IntLit(1), BoundVar("x")), None), - IntLit(55), - ); -let let_fun_menhir = () => +// let get_id_menhir = get_id_menhir_closure(0); + +// let let_fun_menhir = () => +// alco_check( +// "Let expression for function (str elaborated using the menhir parser)", +// Some( +// Haz3lcore.DHExp.of_menhir_ast( +// Hazel_menhir.Interface.parse_program(str10), +// get_id_menhir, +// ), +// ), +// dhexp_of_uexp(u9), +// ); + +let str11 = "()"; + +// let get_id_menhir = get_id_menhir_closure(0); + +// let empty_hole_menhir = () => +// alco_check( +// "Empty hole (str elaborated using the menhir parser)", +// Some( +// Haz3lcore.DHExp.of_menhir_ast( +// Hazel_menhir.Interface.parse_program(str11), +// get_id_menhir, +// ), +// ), +// dhexp_of_uexp(u2), +// ); + +let u3: Term.UExp.t = { + ids: [id_at(0)], + term: Parens({ids: [id_at(1)], term: Var("y")}), +}; +// let d3: DHExp.t = +// NonEmptyHole(TypeInconsistent, id_at(1), 0, FreeVar(id_at(1), 0, "y")); + +let get_id_menhir = get_id_menhir_closure(1); + +let free_var_menhir = () => alco_check( - "Let expression for function (str elaborated using the menhir parser)", - Some(d10), + "Nonempty hole with free variable (menhir)", Some( Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program(str10), + Hazel_menhir.Interface.parse_program("(_FREE y)"), + get_id_menhir, ), ), + dhexp_of_uexp(u3), ); let elaboration_tests = [ @@ -312,5 +365,7 @@ let elaboration_tests = [ test_case("Application of function on free variable", `Quick, ap_fun), test_case("Inconsistent case statement", `Quick, inconsistent_case), test_case("Let expression for a function", `Quick, let_fun), - test_case("Let expression for a function (menhir)", `Quick, let_fun_menhir), + // test_case("Let expression for a function (menhir)", `Quick, let_fun_menhir), + // test_case("Empty hole menhir", `Quick, empty_hole_menhir), + test_case("Free var menhir", `Quick, free_var_menhir), ]; diff --git a/src/test/Test_Menhir.re b/src/test/Test_Menhir.re index fdd584b8b4..c2fc70e984 100644 --- a/src/test/Test_Menhir.re +++ b/src/test/Test_Menhir.re @@ -72,7 +72,7 @@ let parser_test = (a, expected, actual, ()) => // ), // ); -let fun_exp = AST.Fun(IntType, VarPat("x"), Var("x")); +let fun_exp = AST.Fun(IntType, VarPat("x"), Var("x"), None); let fun_str = "fun: Int x -> x"; From e3060a7f1f5c40f79c549494d5aa118085095789 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 5 Apr 2024 12:49:30 -0400 Subject: [PATCH 020/281] added inconsistent branch handling to the menhir parser for testing branch holes --- src/haz3lcore/dynamics/DH.re | 40 ++++----- src/haz3lcore/dynamics/DHPat.re | 1 + src/menhir-parser/AST.re | 2 + src/menhir-parser/Parser.mly | 3 + src/test/Test_Elaboration.re | 152 ++++++++++++++++++++++++++------ 5 files changed, 147 insertions(+), 51 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index a84f859eca..0cdd5af80d 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -357,7 +357,7 @@ module rec DHExp: { and of_menhir_ast = (exp: Hazel_menhir.AST.exp, getId: bool => Id.t): t => { let of_menhir_ast_noid = of_menhir_ast(_, getId); let getId_all_args = getId; - // let getId_no_inc = () => getId(false); + let getId_no_inc = () => getId(false); let getId = () => getId(true); switch (exp) { @@ -366,7 +366,7 @@ module rec DHExp: { | String(s) => StringLit(s) | Bool(b) => BoolLit(b) | Var(x) => BoundVar(x) - | FreeVar(x) => FreeVar(getId_all_args(false), 0, x) + | FreeVar(x) => FreeVar(getId_no_inc(), 0, x) | ArrayExp(l) => ListLit( Id.mk(), @@ -404,23 +404,17 @@ module rec DHExp: { | BinExp(e1, op, e2) => switch (op) { | IntOp(op) => - BinIntOp( - TermBase.UExp.int_op_of_menhir_ast(op), - of_menhir_ast_noid(e1), - of_menhir_ast_noid(e2), - ) + let e1 = of_menhir_ast_noid(e1); + let e2 = of_menhir_ast_noid(e2); + BinIntOp(TermBase.UExp.int_op_of_menhir_ast(op), e1, e2); | FloatOp(op) => - BinFloatOp( - TermBase.UExp.float_op_of_menhir_ast(op), - of_menhir_ast_noid(e1), - of_menhir_ast_noid(e2), - ) + let e1 = of_menhir_ast_noid(e1); + let e2 = of_menhir_ast_noid(e2); + BinFloatOp(TermBase.UExp.float_op_of_menhir_ast(op), e1, e2); | BoolOp(op) => - BinBoolOp( - TermBase.UExp.bool_op_of_menhir_ast(op), - of_menhir_ast_noid(e1), - of_menhir_ast_noid(e2), - ) + let e1 = of_menhir_ast_noid(e1); + let e2 = of_menhir_ast_noid(e2); + BinBoolOp(TermBase.UExp.bool_op_of_menhir_ast(op), e1, e2); } | If(e1, e2, e3) => let d_scrut = of_menhir_ast_noid(e1); @@ -436,6 +430,10 @@ module rec DHExp: { let d_scrut = of_menhir_ast_noid(e); let d_rules = List.map(rule_of_menhir_ast(_, getId_all_args), l); ConsistentCase(Case(d_scrut, d_rules, 0)); + | InconsistentCaseExp(e, l) => + let d_scrut = of_menhir_ast_noid(e); + let d_rules = List.map(rule_of_menhir_ast(_, getId_all_args), l); + InconsistentBranches(getId_no_inc(), 0, Case(d_scrut, d_rules, 0)); | Cast(e, t1, t2) => Cast( of_menhir_ast_noid(e), @@ -445,12 +443,8 @@ module rec DHExp: { | EmptyHole => EmptyHole(getId(), 0) | NonEmptyHole(e) => let id = getId(); - NonEmptyHole( - ErrStatus.HoleReason.TypeInconsistent, - id, - 0, - of_menhir_ast_noid(e), - ); + let e = of_menhir_ast_noid(e); + NonEmptyHole(ErrStatus.HoleReason.TypeInconsistent, id, 0, e); // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) }; }; diff --git a/src/haz3lcore/dynamics/DHPat.re b/src/haz3lcore/dynamics/DHPat.re index ee15179883..854011dde9 100644 --- a/src/haz3lcore/dynamics/DHPat.re +++ b/src/haz3lcore/dynamics/DHPat.re @@ -59,6 +59,7 @@ let rec of_menhir_ast = (pat: Hazel_menhir.AST.pat): t => { | TypeAnn(pat, _typ) => of_menhir_ast(pat) | TuplePat(pats) => Tuple(List.map(of_menhir_ast, pats)) | ApPat(pat1, pat2) => Ap(of_menhir_ast(pat1), of_menhir_ast(pat2)) + | BoolPat(b) => BoolLit(b) }; }; diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 4993b873f0..10153fe363 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -58,6 +58,7 @@ type pat = | StringPat(string) | TypeAnn(pat, typ) | TuplePat(list(pat)) + | BoolPat(bool) | ApPat(pat, pat); [@deriving (show({with_path: false}), sexp, yojson)] @@ -74,6 +75,7 @@ type exp = | Fun(typ, pat, exp, option(string)) | FixF(string, typ, exp) | CaseExp(exp, list((pat, exp))) + | InconsistentCaseExp(exp, list((pat, exp))) | ApExp(exp, exp) | Bool(bool) | Cast(exp, typ, typ) diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index e4f3fbd254..fd2528e2c3 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -141,6 +141,8 @@ pat: | i = INT { IntPat i } | f = FLOAT { FloatPat f } | s = STRING { StringPat s} + | TRUE { BoolPat true} + | FALSE {BoolPat false} (* | p1 = pat; AS; p2 = pat; { AsPat(p1, p2) } *) | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } @@ -156,6 +158,7 @@ rul: case: | CASE; e = exp; l = list(rul); END; { CaseExp(e, l) } + | OPEN_PAREN; CASE; e = exp; l = list(rul); END; CLOSE_PAREN { InconsistentCaseExp(e, l)} funExp: | FUN; COLON; t = typ; p = pat; DASH_ARROW; e1 = exp; { Fun (t, p, e1, None) } diff --git a/src/test/Test_Elaboration.re b/src/test/Test_Elaboration.re index d781ea7e3e..8deda81f25 100644 --- a/src/test/Test_Elaboration.re +++ b/src/test/Test_Elaboration.re @@ -304,35 +304,35 @@ let f : Int -> Int = in 55"; -// let get_id_menhir = get_id_menhir_closure(0); - -// let let_fun_menhir = () => -// alco_check( -// "Let expression for function (str elaborated using the menhir parser)", -// Some( -// Haz3lcore.DHExp.of_menhir_ast( -// Hazel_menhir.Interface.parse_program(str10), -// get_id_menhir, -// ), -// ), -// dhexp_of_uexp(u9), -// ); +let get_id_menhir = get_id_menhir_closure(0); + +let let_fun_menhir = () => + alco_check( + "Let expression for function (str elaborated using the menhir parser)", + Some( + Haz3lcore.DHExp.of_menhir_ast( + Hazel_menhir.Interface.parse_program(str10), + get_id_menhir, + ), + ), + dhexp_of_uexp(u9), + ); let str11 = "()"; -// let get_id_menhir = get_id_menhir_closure(0); - -// let empty_hole_menhir = () => -// alco_check( -// "Empty hole (str elaborated using the menhir parser)", -// Some( -// Haz3lcore.DHExp.of_menhir_ast( -// Hazel_menhir.Interface.parse_program(str11), -// get_id_menhir, -// ), -// ), -// dhexp_of_uexp(u2), -// ); +let get_id_menhir = get_id_menhir_closure(0); + +let empty_hole_menhir = () => + alco_check( + "Empty hole (str elaborated using the menhir parser)", + Some( + Haz3lcore.DHExp.of_menhir_ast( + Hazel_menhir.Interface.parse_program(str11), + get_id_menhir, + ), + ), + dhexp_of_uexp(u2), + ); let u3: Term.UExp.t = { ids: [id_at(0)], @@ -355,6 +355,100 @@ let free_var_menhir = () => dhexp_of_uexp(u3), ); +let get_id_menhir = get_id_menhir_closure(1); + +let u5: Term.UExp.t = { + ids: [id_at(0)], + term: + BinOp( + Int(Plus), + {ids: [id_at(1)], term: Bool(false)}, + {ids: [id_at(2)], term: Var("y")}, + ), +}; +// let d5: DHExp.t = +// BinIntOp( +// Plus, +// NonEmptyHole(TypeInconsistent, id_at(1), 0, BoolLit(false)), +// NonEmptyHole(TypeInconsistent, id_at(2), 0, FreeVar(id_at(2), 0, "y")), +// ); + +let bin_op_menhir = () => + alco_check( + "Inconsistent binary integer operation (plus)", + Some( + Haz3lcore.DHExp.of_menhir_ast( + Hazel_menhir.Interface.parse_program("(false) + (_FREE y)"), + get_id_menhir, + ), + ), + dhexp_of_uexp(u5), + ); + +let get_id_menhir = get_id_menhir_closure(0); + +//Inconsistent branches menhir test +let str8 = " + ( (case 4 == 3 + | true => 24 + | false => false + end) ) +"; + +// let str8 = " +// case 4 == 3 +// | true => 24 +// | false => 2 +// end +// "; + +let u8: Term.UExp.t = { + ids: [id_at(0)], + term: + Match( + { + ids: [id_at(1)], + term: + BinOp( + Int(Equals), + {ids: [id_at(2)], term: Int(4)}, + {ids: [id_at(3)], term: Int(3)}, + ), + }, + [ + ( + {ids: [id_at(6)], term: Bool(true)}, + {ids: [id_at(4)], term: Int(24)}, + ), + ( + {ids: [id_at(7)], term: Bool(false)}, + {ids: [id_at(5)], term: Bool(false)}, + ), + ], + ), +}; +// let d8scrut: DHExp.t = BinIntOp(Equals, IntLit(4), IntLit(3)); +// let d8rules = +// DHExp.[ +// Rule(BoolLit(true), IntLit(24)), +// Rule(BoolLit(false), BoolLit(false)), +// ]; +// let d8a: DHExp.t = +// InconsistentBranches(id_at(0), 0, Case(d8scrut, d8rules, 0)); +// let d8: DHExp.t = NonEmptyHole(TypeInconsistent, id_at(0), 0, d8a); + +let inconsistent_case_menhir = () => + alco_check( + "Inconsistent branches where the first branch is an integer and second branch is a boolean (menhir)", + Some( + Haz3lcore.DHExp.of_menhir_ast( + Hazel_menhir.Interface.parse_program(str8), + get_id_menhir, + ), + ), + dhexp_of_uexp(u8), + ); + let elaboration_tests = [ test_case("Single integer", `Quick, single_integer), test_case("Empty hole", `Quick, empty_hole), @@ -365,7 +459,9 @@ let elaboration_tests = [ test_case("Application of function on free variable", `Quick, ap_fun), test_case("Inconsistent case statement", `Quick, inconsistent_case), test_case("Let expression for a function", `Quick, let_fun), - // test_case("Let expression for a function (menhir)", `Quick, let_fun_menhir), - // test_case("Empty hole menhir", `Quick, empty_hole_menhir), + test_case("Let expression for a function (menhir)", `Quick, let_fun_menhir), + test_case("Empty hole menhir", `Quick, empty_hole_menhir), test_case("Free var menhir", `Quick, free_var_menhir), + test_case("Bin op menhir", `Quick, bin_op_menhir), + test_case("Inconsistent case menhir", `Quick, inconsistent_case_menhir), ]; From 6b1331714edbee4af83f9548779486c52d96545c Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sat, 6 Apr 2024 14:32:52 -0400 Subject: [PATCH 021/281] reworked hole syntax + added unknown types + changed expression parsing to better handle parens + added free var application elaboration test with menhir --- src/haz3lcore/statics/TypBase.re | 4 ++ src/menhir-parser/AST.re | 5 +++ src/menhir-parser/Lexer.mll | 3 ++ src/menhir-parser/Parser.mly | 11 ++++- src/test/Test_Elaboration.re | 72 +++++++++++++++++++++++++++----- 5 files changed, 84 insertions(+), 11 deletions(-) diff --git a/src/haz3lcore/statics/TypBase.re b/src/haz3lcore/statics/TypBase.re index 5ac916742f..0c2f09a035 100644 --- a/src/haz3lcore/statics/TypBase.re +++ b/src/haz3lcore/statics/TypBase.re @@ -435,6 +435,10 @@ module rec Typ: { | BoolType => Bool | StringType => String | UnitType => Prod([]) + | UnknownType(p) => + switch (p) { + | Internal => Unknown(Internal) + } | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) | ArrayType(t) => List(of_menhir_ast(t)) | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 10153fe363..6a7ecc4322 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -39,6 +39,10 @@ type binOp = | FloatOp(op_bin_float) | BoolOp(op_bin_bool); +[@deriving (show({with_path: false}), sexp, yojson)] +type typ_provenance = + | Internal; + [@deriving (show({with_path: false}), sexp, yojson)] type typ = | IntType @@ -46,6 +50,7 @@ type typ = | FloatType | BoolType | UnitType + | UnknownType(typ_provenance) | TupleType(list(typ)) | ArrayType(typ) | ArrowType(typ, typ); diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll index 18e3190b4a..199e295845 100644 --- a/src/menhir-parser/Lexer.mll +++ b/src/menhir-parser/Lexer.mll @@ -86,9 +86,12 @@ rule token = | "Float" { FLOAT_TYPE } | "Bool" { BOOL_TYPE } | "String" { STRING_TYPE } + | "Unknown" { UNKNOWN } + | "Internal" { INTERNAL } | "()" { UNIT } | "_FIX" {FIX} | "_FREE" {FREE} + | "_HOLE" {HOLE} | identifier as i { IDENT(i) } | eof { EOF } | _ { raise (Failure ("Lex error: unknown char: '" ^ Lexing.lexeme lexbuf ^ "'")) } diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index fd2528e2c3..8a0f772c5f 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -2,6 +2,9 @@ open AST %} + + +%token HOLE %token FREE %token FIX %token IDENT @@ -68,6 +71,8 @@ open AST %token FLOAT_TYPE %token BOOL_TYPE %token STRING_TYPE +%token UNKNOWN +%token INTERNAL %token IF %token THEN @@ -126,6 +131,7 @@ typ: | FLOAT_TYPE { FloatType } | BOOL_TYPE { BoolType } | STRING_TYPE { StringType } + | UNKNOWN; INTERNAL { UnknownType(Internal) } | UNIT { UnitType } | OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { TupleType(types) } | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } @@ -172,6 +178,7 @@ exp: | FREE; v = IDENT { FreeVar v } | s = STRING { String s} | b = binExp { b } + | OPEN_PAREN; e = exp; CLOSE_PAREN { e } | OPEN_PAREN; l = separated_list(COMMA, exp) ; CLOSE_PAREN { TupleExp(l)} | c = case { c } | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ArrayExp(e) } @@ -183,5 +190,7 @@ exp: | FIX; s = IDENT; t = typ; f = funExp { FixF(s, t, f) } | f = funExp {f} | FALSE { Bool false } - | OPEN_PAREN; e = exp; CLOSE_PAREN { NonEmptyHole(e) } + | OPEN_PAREN; HOLE; e = exp; CLOSE_PAREN {NonEmptyHole e} + | HOLE { EmptyHole } + (* | OPEN_PAREN; e = exp; CLOSE_PAREN { NonEmptyHole(e) } *) | UNIT { EmptyHole } diff --git a/src/test/Test_Elaboration.re b/src/test/Test_Elaboration.re index 8deda81f25..ceb576474e 100644 --- a/src/test/Test_Elaboration.re +++ b/src/test/Test_Elaboration.re @@ -348,7 +348,7 @@ let free_var_menhir = () => "Nonempty hole with free variable (menhir)", Some( Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program("(_FREE y)"), + Hazel_menhir.Interface.parse_program("(_HOLE _FREE y)"), get_id_menhir, ), ), @@ -378,7 +378,9 @@ let bin_op_menhir = () => "Inconsistent binary integer operation (plus)", Some( Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program("(false) + (_FREE y)"), + Hazel_menhir.Interface.parse_program( + "(_HOLE false) + (_HOLE _FREE y)", + ), get_id_menhir, ), ), @@ -389,19 +391,12 @@ let get_id_menhir = get_id_menhir_closure(0); //Inconsistent branches menhir test let str8 = " - ( (case 4 == 3 + (_HOLE (case 4 == 3 | true => 24 | false => false end) ) "; -// let str8 = " -// case 4 == 3 -// | true => 24 -// | false => 2 -// end -// "; - let u8: Term.UExp.t = { ids: [id_at(0)], term: @@ -449,6 +444,62 @@ let inconsistent_case_menhir = () => dhexp_of_uexp(u8), ); +let get_id_menhir = get_id_menhir_closure(6); +let u7: Term.UExp.t = { + ids: [id_at(0)], + term: + Ap( + { + ids: [id_at(1)], + term: + Fun( + {ids: [id_at(2)], term: Var("x")}, + { + ids: [id_at(3)], + term: + BinOp( + Int(Plus), + {ids: [id_at(4)], term: Int(4)}, + {ids: [id_at(5)], term: Var("x")}, + ), + }, + ), + }, + {ids: [id_at(6)], term: Var("y")}, + ), +}; + +// let d7: DHExp.t = +// Ap( +// Fun( +// Var("x"), +// Unknown(Internal), +// BinIntOp( +// Plus, +// IntLit(4), +// Cast(BoundVar("x"), Unknown(Internal), Int), +// ), +// None, +// ), +// NonEmptyHole(TypeInconsistent, id_at(6), 0, FreeVar(id_at(6), 0, "y")), +// ); + +let str7 = " + (fun: Unknown Internal x -> 4 + x Int>)((_HOLE _FREE y)) +"; + +let ap_fun_menhir = () => + alco_check( + "Application of a function of a free variable wrapped inside a nonempty hole constructor (menhir)", + Some( + Haz3lcore.DHExp.of_menhir_ast( + Hazel_menhir.Interface.parse_program(str7), + get_id_menhir, + ), + ), + dhexp_of_uexp(u7), + ); + let elaboration_tests = [ test_case("Single integer", `Quick, single_integer), test_case("Empty hole", `Quick, empty_hole), @@ -464,4 +515,5 @@ let elaboration_tests = [ test_case("Free var menhir", `Quick, free_var_menhir), test_case("Bin op menhir", `Quick, bin_op_menhir), test_case("Inconsistent case menhir", `Quick, inconsistent_case_menhir), + test_case("ap fun menhir", `Quick, ap_fun_menhir), ]; From 04488465d0a96a44809293b255193c8f8fcda865 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sat, 6 Apr 2024 16:09:47 -0400 Subject: [PATCH 022/281] fixed the ifthenelse menhir -> dhexp translation + added menhir ifthenelse test case --- src/haz3lcore/dynamics/DH.re | 6 +----- src/test/Test_Elaboration.re | 28 ++++++++++++++++++++++++++++ 2 files changed, 29 insertions(+), 5 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index 0cdd5af80d..019e262a8a 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -421,11 +421,7 @@ module rec DHExp: { let d1 = of_menhir_ast_noid(e2); let d2 = of_menhir_ast_noid(e3); - let d_rules = - DHExp.[Rule(BoolLit(true), d1), Rule(BoolLit(false), d2)]; - let d = DHExp.Case(d_scrut, d_rules, 0); - ConsistentCase(d); - + IfThenElse(ConsistentIf, d_scrut, d1, d2); | CaseExp(e, l) => let d_scrut = of_menhir_ast_noid(e); let d_rules = List.map(rule_of_menhir_ast(_, getId_all_args), l); diff --git a/src/test/Test_Elaboration.re b/src/test/Test_Elaboration.re index ceb576474e..89f53d8c35 100644 --- a/src/test/Test_Elaboration.re +++ b/src/test/Test_Elaboration.re @@ -500,6 +500,33 @@ let ap_fun_menhir = () => dhexp_of_uexp(u7), ); +let get_id_menhir = get_id_menhir_closure(6); +let u6: Term.UExp.t = { + ids: [id_at(0)], + term: + If( + {ids: [id_at(1)], term: Bool(false)}, + {ids: [id_at(2)], term: Int(8)}, + {ids: [id_at(3)], term: Int(6)}, + ), +}; +// let d6: DHExp.t = +// IfThenElse(DH.ConsistentIf, BoolLit(false), IntLit(8), IntLit(6)); +let str6 = " + if false then 8 else 6 +"; +let consistent_if_menhir = () => + alco_check( + "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", + Some( + Haz3lcore.DHExp.of_menhir_ast( + Hazel_menhir.Interface.parse_program(str6), + get_id_menhir, + ), + ), + dhexp_of_uexp(u6), + ); + let elaboration_tests = [ test_case("Single integer", `Quick, single_integer), test_case("Empty hole", `Quick, empty_hole), @@ -516,4 +543,5 @@ let elaboration_tests = [ test_case("Bin op menhir", `Quick, bin_op_menhir), test_case("Inconsistent case menhir", `Quick, inconsistent_case_menhir), test_case("ap fun menhir", `Quick, ap_fun_menhir), + test_case("Consistent if menhir", `Quick, consistent_if_menhir), ]; From 595c6f77ec5e438e22af5e2c32d0564219bcae7e Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 8 Apr 2024 17:22:47 -0400 Subject: [PATCH 023/281] added if consistency & test case for inconsistent if --- src/haz3lcore/dynamics/DH.re | 9 +++++++-- src/menhir-parser/AST.re | 7 ++++++- src/menhir-parser/Parser.mly | 6 +++++- src/test/Test_Elaboration.re | 26 ++++++++++++++++++++++++++ 4 files changed, 44 insertions(+), 4 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index 019e262a8a..0ac8b4ccba 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -416,12 +416,17 @@ module rec DHExp: { let e2 = of_menhir_ast_noid(e2); BinBoolOp(TermBase.UExp.bool_op_of_menhir_ast(op), e1, e2); } - | If(e1, e2, e3) => + | If(consistency, e1, e2, e3) => let d_scrut = of_menhir_ast_noid(e1); let d1 = of_menhir_ast_noid(e2); let d2 = of_menhir_ast_noid(e3); + let consistency = + switch (consistency) { + | Consistent => ConsistentIf + | Inconsistent => InconsistentIf + }; - IfThenElse(ConsistentIf, d_scrut, d1, d2); + IfThenElse(consistency, d_scrut, d1, d2); | CaseExp(e, l) => let d_scrut = of_menhir_ast_noid(e); let d_rules = List.map(rule_of_menhir_ast(_, getId_all_args), l); diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 6a7ecc4322..2a059e3826 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -66,6 +66,11 @@ type pat = | BoolPat(bool) | ApPat(pat, pat); +[@deriving (show({with_path: false}), sexp, yojson)] +type if_consistency = + | Consistent + | Inconsistent; + [@deriving (show({with_path: false}), sexp, yojson)] type exp = | Int(int) @@ -86,4 +91,4 @@ type exp = | Cast(exp, typ, typ) | NonEmptyHole(exp) | EmptyHole - | If(exp, exp, exp); + | If(if_consistency, exp, exp, exp); diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index 8a0f772c5f..a2d14defb0 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -171,6 +171,10 @@ funExp: | FUN; COLON; t = typ; p = pat; DASH_ARROW; e1 = exp; name = IDENT { Fun (t, p, e1, Some(name)) } +ifExp: + | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (Consistent, e1, e2, e3) } + | HOLE; IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (Inconsistent, e1, e2, e3) } + exp: | i = INT { Int i } | f = FLOAT { Float f } @@ -184,7 +188,7 @@ exp: | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ArrayExp(e) } | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } - | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (e1, e2, e3) } + | i = ifExp { i} | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } | TRUE { Bool true } | FIX; s = IDENT; t = typ; f = funExp { FixF(s, t, f) } diff --git a/src/test/Test_Elaboration.re b/src/test/Test_Elaboration.re index 89f53d8c35..3efa147017 100644 --- a/src/test/Test_Elaboration.re +++ b/src/test/Test_Elaboration.re @@ -527,6 +527,32 @@ let consistent_if_menhir = () => dhexp_of_uexp(u6), ); + +let u12: Term.UExp.t = { + ids: [id_at(0)], + term: + If( + {ids: [id_at(1)], term: Bool(false)}, + {ids: [id_at(2)], term: Int(8)}, + {ids: [id_at(3)], term: Bool(true)}, + ), +} + +let str12 = "" + +let inconsistent_if_menhir = () => + alco_check( + "Inconsistent if statement (menhir)", + Some( + Haz3lcore.DHExp.of_menhir_ast( + Hazel_menhir.Interface.parse_program(str12), + get_id_menhir, + ), + ), + dhexp_of_uexp(u6), + ); + + let elaboration_tests = [ test_case("Single integer", `Quick, single_integer), test_case("Empty hole", `Quick, empty_hole), From 2ba24dfd378395cf50a5cd2abc922a562b2a61fb Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 22 Apr 2024 14:30:05 -0400 Subject: [PATCH 024/281] cleaned up the test_elaboration file and removed all non-menhir tests --- src/test/Test_Elaboration.re | 441 ++++++++--------------------------- 1 file changed, 96 insertions(+), 345 deletions(-) diff --git a/src/test/Test_Elaboration.re b/src/test/Test_Elaboration.re index 3efa147017..c41b923417 100644 --- a/src/test/Test_Elaboration.re +++ b/src/test/Test_Elaboration.re @@ -42,201 +42,20 @@ let mk_map = CoreSettings.on |> Interface.Statics.mk_map; let dhexp_of_uexp = u => Elaborator.dhexp_of_uexp(mk_map(u), u, false); let alco_check = dhexp_typ |> Alcotest.check; -let u1: Term.UExp.t = {ids: [id_at(0)], term: Int(8)}; -let single_integer = () => - alco_check("Integer literal 8", Some(IntLit(8)), dhexp_of_uexp(u1)); - -let u2: Term.UExp.t = {ids: [id_at(0)], term: EmptyHole}; -let empty_hole = () => - alco_check( - "Empty hole", - Some(EmptyHole(id_at(0), 0)), - dhexp_of_uexp(u2), - ); - -let u3: Term.UExp.t = { - ids: [id_at(0)], - term: Parens({ids: [id_at(1)], term: Var("y")}), -}; -let d3: DHExp.t = - NonEmptyHole(TypeInconsistent, id_at(1), 0, FreeVar(id_at(1), 0, "y")); -let free_var = () => +let alco_check_menhir = (name: string, dhexp: string, uexp: Term.UExp.t) => alco_check( - "Nonempty hole with free variable", - Some(d3), - dhexp_of_uexp(u3), - ); - -let u4: Term.UExp.t = { - ids: [id_at(0)], - term: - Let( - { - ids: [id_at(1)], - term: - Tuple([ - {ids: [id_at(2)], term: Var("a")}, - {ids: [id_at(3)], term: Var("b")}, - ]), - }, - { - ids: [id_at(4)], - term: - Tuple([ - {ids: [id_at(5)], term: Int(4)}, - {ids: [id_at(6)], term: Int(6)}, - ]), - }, - { - ids: [id_at(7)], - term: - BinOp( - Int(Minus), - {ids: [id_at(8)], term: Var("a")}, - {ids: [id_at(9)], term: Var("b")}, - ), - }, - ), -}; -let d4: DHExp.t = - Let( - Tuple([Var("a"), Var("b")]), - Tuple([IntLit(4), IntLit(6)]), - BinIntOp(Minus, BoundVar("a"), BoundVar("b")), - ); -let let_exp = () => - alco_check( - "Let expression for tuple (a, b)", - Some(d4), - dhexp_of_uexp(u4), - ); - -let u5: Term.UExp.t = { - ids: [id_at(0)], - term: - BinOp( - Int(Plus), - {ids: [id_at(1)], term: Bool(false)}, - {ids: [id_at(2)], term: Var("y")}, - ), -}; -let d5: DHExp.t = - BinIntOp( - Plus, - NonEmptyHole(TypeInconsistent, id_at(1), 0, BoolLit(false)), - NonEmptyHole(TypeInconsistent, id_at(2), 0, FreeVar(id_at(2), 0, "y")), - ); -let bin_op = () => - alco_check( - "Inconsistent binary integer operation (plus)", - Some(d5), - dhexp_of_uexp(u5), - ); - -let u6: Term.UExp.t = { - ids: [id_at(0)], - term: - If( - {ids: [id_at(1)], term: Bool(false)}, - {ids: [id_at(2)], term: Int(8)}, - {ids: [id_at(3)], term: Int(6)}, - ), -}; -let d6: DHExp.t = - IfThenElse(DH.ConsistentIf, BoolLit(false), IntLit(8), IntLit(6)); -let consistent_if = () => - alco_check( - "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", - Some(d6), - dhexp_of_uexp(u6), - ); - -let u7: Term.UExp.t = { - ids: [id_at(0)], - term: - Ap( - { - ids: [id_at(1)], - term: - Fun( - {ids: [id_at(2)], term: Var("x")}, - { - ids: [id_at(3)], - term: - BinOp( - Int(Plus), - {ids: [id_at(4)], term: Int(4)}, - {ids: [id_at(5)], term: Var("x")}, - ), - }, - ), - }, - {ids: [id_at(6)], term: Var("y")}, - ), -}; -let d7: DHExp.t = - Ap( - Fun( - Var("x"), - Unknown(Internal), - BinIntOp( - Plus, - IntLit(4), - Cast(BoundVar("x"), Unknown(Internal), Int), + name, + Some( + Haz3lcore.DHExp.of_menhir_ast( + Hazel_menhir.Interface.parse_program(dhexp), + get_id_menhir_closure(0), ), - None, ), - NonEmptyHole(TypeInconsistent, id_at(6), 0, FreeVar(id_at(6), 0, "y")), - ); -let ap_fun = () => - alco_check( - "Application of a function of a free variable wrapped inside a nonempty hole constructor", - Some(d7), - dhexp_of_uexp(u7), + dhexp_of_uexp(uexp), ); -let u8: Term.UExp.t = { - ids: [id_at(0)], - term: - Match( - { - ids: [id_at(1)], - term: - BinOp( - Int(Equals), - {ids: [id_at(2)], term: Int(4)}, - {ids: [id_at(3)], term: Int(3)}, - ), - }, - [ - ( - {ids: [id_at(6)], term: Bool(true)}, - {ids: [id_at(4)], term: Int(24)}, - ), - ( - {ids: [id_at(7)], term: Bool(false)}, - {ids: [id_at(5)], term: Bool(false)}, - ), - ], - ), -}; -let d8scrut: DHExp.t = BinIntOp(Equals, IntLit(4), IntLit(3)); -let d8rules = - DHExp.[ - Rule(BoolLit(true), IntLit(24)), - Rule(BoolLit(false), BoolLit(false)), - ]; -let d8a: DHExp.t = - InconsistentBranches(id_at(0), 0, Case(d8scrut, d8rules, 0)); -let d8: DHExp.t = NonEmptyHole(TypeInconsistent, id_at(0), 0, d8a); -let inconsistent_case = () => - alco_check( - "Inconsistent branches where the first branch is an integer and second branch is a boolean", - Some(d8), - dhexp_of_uexp(u8), - ); - -let u9: Term.UExp.t = { +//Test for a let function +let let_fun_uexp: Term.UExp.t = { ids: [id_at(0)], term: Let( @@ -274,90 +93,49 @@ let u9: Term.UExp.t = { {ids: [id_at(11)], term: Int(55)}, ), }; -let d9: DHExp.t = - Let( - Var("f"), - FixF( - "f", - Arrow(Int, Int), - Fun( - Var("x"), - Int, - BinIntOp(Plus, IntLit(1), BoundVar("x")), - Some("f"), - ), - ), - IntLit(55), - ); -let let_fun = () => - alco_check( - "Let expression for function which wraps a fix point constructor around the function", - Some(d9), - dhexp_of_uexp(u9), - ); - -let str10 = " +let let_fun_str = " let f : Int -> Int = _FIX f Int -> Int fun: Int x -> 1 + x f in 55"; - -let get_id_menhir = get_id_menhir_closure(0); - let let_fun_menhir = () => - alco_check( + alco_check_menhir( "Let expression for function (str elaborated using the menhir parser)", - Some( - Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program(str10), - get_id_menhir, - ), - ), - dhexp_of_uexp(u9), + let_fun_str, + let_fun_uexp, ); -let str11 = "()"; - -let get_id_menhir = get_id_menhir_closure(0); - +//Test for an empty hole +let empty_hole_str = "()"; +let empty_hole_uexp: Term.UExp.t = {ids: [id_at(0)], term: EmptyHole}; let empty_hole_menhir = () => - alco_check( + alco_check_menhir( "Empty hole (str elaborated using the menhir parser)", - Some( - Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program(str11), - get_id_menhir, - ), - ), - dhexp_of_uexp(u2), + empty_hole_str, + empty_hole_uexp, ); -let u3: Term.UExp.t = { +//Test for a free variable +let free_var_uexp: Term.UExp.t = { ids: [id_at(0)], term: Parens({ids: [id_at(1)], term: Var("y")}), }; -// let d3: DHExp.t = -// NonEmptyHole(TypeInconsistent, id_at(1), 0, FreeVar(id_at(1), 0, "y")); - -let get_id_menhir = get_id_menhir_closure(1); - let free_var_menhir = () => alco_check( "Nonempty hole with free variable (menhir)", Some( Haz3lcore.DHExp.of_menhir_ast( Hazel_menhir.Interface.parse_program("(_HOLE _FREE y)"), - get_id_menhir, + get_id_menhir_closure(1), ), ), - dhexp_of_uexp(u3), + dhexp_of_uexp(free_var_uexp), ); -let get_id_menhir = get_id_menhir_closure(1); - -let u5: Term.UExp.t = { +//Menhir test for a binary operation +let bin_op_uexp: Term.UExp.t = { ids: [id_at(0)], term: BinOp( @@ -366,13 +144,6 @@ let u5: Term.UExp.t = { {ids: [id_at(2)], term: Var("y")}, ), }; -// let d5: DHExp.t = -// BinIntOp( -// Plus, -// NonEmptyHole(TypeInconsistent, id_at(1), 0, BoolLit(false)), -// NonEmptyHole(TypeInconsistent, id_at(2), 0, FreeVar(id_at(2), 0, "y")), -// ); - let bin_op_menhir = () => alco_check( "Inconsistent binary integer operation (plus)", @@ -381,23 +152,20 @@ let bin_op_menhir = () => Hazel_menhir.Interface.parse_program( "(_HOLE false) + (_HOLE _FREE y)", ), - get_id_menhir, + get_id_menhir_closure(1), ), ), - dhexp_of_uexp(u5), + dhexp_of_uexp(bin_op_uexp), ); -let get_id_menhir = get_id_menhir_closure(0); - //Inconsistent branches menhir test -let str8 = " +let inconsistent_case_menhir_str = " (_HOLE (case 4 == 3 | true => 24 | false => false end) ) "; - -let u8: Term.UExp.t = { +let inconsistent_case_uexp: Term.UExp.t = { ids: [id_at(0)], term: Match( @@ -422,30 +190,15 @@ let u8: Term.UExp.t = { ], ), }; -// let d8scrut: DHExp.t = BinIntOp(Equals, IntLit(4), IntLit(3)); -// let d8rules = -// DHExp.[ -// Rule(BoolLit(true), IntLit(24)), -// Rule(BoolLit(false), BoolLit(false)), -// ]; -// let d8a: DHExp.t = -// InconsistentBranches(id_at(0), 0, Case(d8scrut, d8rules, 0)); -// let d8: DHExp.t = NonEmptyHole(TypeInconsistent, id_at(0), 0, d8a); - let inconsistent_case_menhir = () => - alco_check( + alco_check_menhir( "Inconsistent branches where the first branch is an integer and second branch is a boolean (menhir)", - Some( - Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program(str8), - get_id_menhir, - ), - ), - dhexp_of_uexp(u8), + inconsistent_case_menhir_str, + inconsistent_case_uexp, ); -let get_id_menhir = get_id_menhir_closure(6); -let u7: Term.UExp.t = { +//Function free var application menhir test +let ap_fun_uexp: Term.UExp.t = { ids: [id_at(0)], term: Ap( @@ -468,40 +221,23 @@ let u7: Term.UExp.t = { {ids: [id_at(6)], term: Var("y")}, ), }; - -// let d7: DHExp.t = -// Ap( -// Fun( -// Var("x"), -// Unknown(Internal), -// BinIntOp( -// Plus, -// IntLit(4), -// Cast(BoundVar("x"), Unknown(Internal), Int), -// ), -// None, -// ), -// NonEmptyHole(TypeInconsistent, id_at(6), 0, FreeVar(id_at(6), 0, "y")), -// ); - -let str7 = " +let ap_fun_str = " (fun: Unknown Internal x -> 4 + x Int>)((_HOLE _FREE y)) "; - let ap_fun_menhir = () => alco_check( "Application of a function of a free variable wrapped inside a nonempty hole constructor (menhir)", Some( Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program(str7), - get_id_menhir, + Hazel_menhir.Interface.parse_program(ap_fun_str), + get_id_menhir_closure(6), ), ), - dhexp_of_uexp(u7), + dhexp_of_uexp(ap_fun_uexp), ); -let get_id_menhir = get_id_menhir_closure(6); -let u6: Term.UExp.t = { +//Consistent if statement menhir test +let consistent_if_uexp: Term.UExp.t = { ids: [id_at(0)], term: If( @@ -510,9 +246,7 @@ let u6: Term.UExp.t = { {ids: [id_at(3)], term: Int(6)}, ), }; -// let d6: DHExp.t = -// IfThenElse(DH.ConsistentIf, BoolLit(false), IntLit(8), IntLit(6)); -let str6 = " +let consistent_if_str = " if false then 8 else 6 "; let consistent_if_menhir = () => @@ -520,54 +254,71 @@ let consistent_if_menhir = () => "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", Some( Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program(str6), - get_id_menhir, + Hazel_menhir.Interface.parse_program(consistent_if_str), + get_id_menhir_closure(6), ), ), - dhexp_of_uexp(u6), + dhexp_of_uexp(consistent_if_uexp), ); +//Single integer menhir test +let single_int_str = "8"; +let single_int_uexp: Term.UExp.t = {ids: [id_at(0)], term: Int(8)}; +let single_integer_menhir = () => + alco_check_menhir( + "Single integer test (menhir)", + single_int_str, + single_int_uexp, + ); -let u12: Term.UExp.t = { +//Menhir let expression test +let let_exp_str = "let (a, b) = (4, 6) in a - b"; +let let_exp_uexp: Term.UExp.t = { ids: [id_at(0)], term: - If( - {ids: [id_at(1)], term: Bool(false)}, - {ids: [id_at(2)], term: Int(8)}, - {ids: [id_at(3)], term: Bool(true)}, - ), -} - -let str12 = "" - -let inconsistent_if_menhir = () => - alco_check( - "Inconsistent if statement (menhir)", - Some( - Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program(str12), - get_id_menhir, - ), + Let( + { + ids: [id_at(1)], + term: + Tuple([ + {ids: [id_at(2)], term: Var("a")}, + {ids: [id_at(3)], term: Var("b")}, + ]), + }, + { + ids: [id_at(4)], + term: + Tuple([ + {ids: [id_at(5)], term: Int(4)}, + {ids: [id_at(6)], term: Int(6)}, + ]), + }, + { + ids: [id_at(7)], + term: + BinOp( + Int(Minus), + {ids: [id_at(8)], term: Var("a")}, + {ids: [id_at(9)], term: Var("b")}, + ), + }, ), - dhexp_of_uexp(u6), +}; +let let_exp_menhir = () => + alco_check_menhir( + "Let expression for tuple (a, b) (menhir)", + let_exp_str, + let_exp_uexp, ); - let elaboration_tests = [ - test_case("Single integer", `Quick, single_integer), - test_case("Empty hole", `Quick, empty_hole), - test_case("Free variable", `Quick, free_var), - test_case("Let expression", `Quick, let_exp), - test_case("Inconsistent binary operation", `Quick, bin_op), - test_case("Consistent if statement", `Quick, consistent_if), - test_case("Application of function on free variable", `Quick, ap_fun), - test_case("Inconsistent case statement", `Quick, inconsistent_case), - test_case("Let expression for a function", `Quick, let_fun), + test_case("Let expression (menhir)", `Quick, let_exp_menhir), + test_case("Single integer (menhir)", `Quick, single_integer_menhir), test_case("Let expression for a function (menhir)", `Quick, let_fun_menhir), - test_case("Empty hole menhir", `Quick, empty_hole_menhir), - test_case("Free var menhir", `Quick, free_var_menhir), - test_case("Bin op menhir", `Quick, bin_op_menhir), - test_case("Inconsistent case menhir", `Quick, inconsistent_case_menhir), - test_case("ap fun menhir", `Quick, ap_fun_menhir), - test_case("Consistent if menhir", `Quick, consistent_if_menhir), + test_case("Empty hole (menhir)", `Quick, empty_hole_menhir), + test_case("Free var (menhir)", `Quick, free_var_menhir), + test_case("Bin op (menhir)", `Quick, bin_op_menhir), + test_case("Inconsistent case (menhir)", `Quick, inconsistent_case_menhir), + test_case("ap fun (menhir)", `Quick, ap_fun_menhir), + test_case("Consistent if (menhir)", `Quick, consistent_if_menhir), ]; From a4d7a938e240c133c66d5a682abbae3c9946a277 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 22 Apr 2024 17:06:28 -0400 Subject: [PATCH 025/281] added the docs as well as cons, seqs, and test to menhir parser --- src/haz3lcore/dynamics/DH.re | 73 +++++++++++++++----------- src/haz3lcore/dynamics/DHPat.re | 1 + src/haz3lcore/dynamics/FilterAction.re | 9 ++++ src/menhir-parser/AST.re | 12 +++++ src/menhir-parser/Lexer.mll | 11 ++++ src/menhir-parser/Parser.mly | 21 +++++++- src/test/Test_Elaboration.re | 2 +- 7 files changed, 96 insertions(+), 33 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index 0ac8b4ccba..465ca8f872 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -7,46 +7,48 @@ type if_consistency = | InconsistentIf; module rec DHExp: { + //All comments show the textual syntax for DHExp when built using the menhir parser [@deriving (show({with_path: false}), sexp, yojson)] type t = - | EmptyHole(MetaVar.t, HoleInstanceId.t) - | NonEmptyHole(ErrStatus.HoleReason.t, MetaVar.t, HoleInstanceId.t, t) + | EmptyHole(MetaVar.t, HoleInstanceId.t) //() + | NonEmptyHole(ErrStatus.HoleReason.t, MetaVar.t, HoleInstanceId.t, t) //(_HOLE x) | ExpandingKeyword(MetaVar.t, HoleInstanceId.t, ExpandingKeyword.t) - | FreeVar(MetaVar.t, HoleInstanceId.t, Var.t) + | FreeVar(MetaVar.t, HoleInstanceId.t, Var.t) //(_FREE x) | InvalidText(MetaVar.t, HoleInstanceId.t, string) - | InconsistentBranches(MetaVar.t, HoleInstanceId.t, case) + | InconsistentBranches(MetaVar.t, HoleInstanceId.t, case) //(_HOLE (case ...)) | Closure([@opaque] ClosureEnvironment.t, t) - | Filter(DHFilter.t, t) - | BoundVar(Var.t) - | Sequence(t, t) - | Let(DHPat.t, t, t) - | FixF(Var.t, Typ.t, t) - | Fun(DHPat.t, Typ.t, t, option(Var.t)) - | Ap(t, t) + | Filter(DHFilter.t, t) //pause a == 2 b + | BoundVar(Var.t) //x + | Sequence(t, t) //a; b + | Let(DHPat.t, t, t) //let x = y in z + | FixF(Var.t, Typ.t, t) //_FIX f Int -> Int fun: Int x -> 1 + x f in 55 + | Fun(DHPat.t, Typ.t, t, option(Var.t)) //fun: Int x -> x + 1 + | Ap(t, t) //a(1) | ApBuiltin(string, t) | BuiltinFun(string) - | Test(KeywordID.t, t) - | BoolLit(bool) - | IntLit(int) - | FloatLit(float) - | StringLit(string) - | BinBoolOp(TermBase.UExp.op_bin_bool, t, t) - | BinIntOp(TermBase.UExp.op_bin_int, t, t) - | BinFloatOp(TermBase.UExp.op_bin_float, t, t) - | BinStringOp(TermBase.UExp.op_bin_string, t, t) - | ListLit(MetaVar.t, MetaVarInst.t, Typ.t, list(t)) - | Cons(t, t) - | ListConcat(t, t) - | Tuple(list(t)) - | Prj(t, int) - | Constructor(string) - | ConsistentCase(case) - | Cast(t, Typ.t, Typ.t) - | FailedCast(t, Typ.t, Typ.t) + | Test(KeywordID.t, t) //test a end + | BoolLit(bool) //true + | IntLit(int) //1 + | FloatLit(float) //1.0 + | StringLit(string) //"hello" + | BinBoolOp(TermBase.UExp.op_bin_bool, t, t) //true && false + | BinIntOp(TermBase.UExp.op_bin_int, t, t) //1 + 2 + | BinFloatOp(TermBase.UExp.op_bin_float, t, t) //1 +. 2 + | BinStringOp(TermBase.UExp.op_bin_string, t, t) // + | ListLit(MetaVar.t, MetaVarInst.t, Typ.t, list(t)) //[a, b, c] + | Cons(t, t) //a :: b + | ListConcat(t, t) //TODO + | Tuple(list(t)) //(a, b) + | Prj(t, int) //TODO + | Constructor(string) //TODO + | ConsistentCase(case) //4 == 3 | true => 24 | false => false end + | Cast(t, Typ.t, Typ.t) //x Int> + | FailedCast(t, Typ.t, Typ.t) //TODO | InvalidOperation(t, InvalidOperationError.t) | IfThenElse(if_consistency, t, t, t) // use bool tag to track if branches are consistent + // if false then 8 else 6 and case = - | Case(t, list(rule), int) + | Case(t, list(rule), int) //4 == 3 | true => 24 | false => false end and rule = | Rule(DHPat.t, t); @@ -446,6 +448,17 @@ module rec DHExp: { let id = getId(); let e = of_menhir_ast_noid(e); NonEmptyHole(ErrStatus.HoleReason.TypeInconsistent, id, 0, e); + | Filter(a, cond, body) => + let dcond = of_menhir_ast_noid(cond); + let dbody = of_menhir_ast_noid(body); + let act = FilterAction.of_menhir_ast(a); + Filter(Filter(Filter.mk(dcond, act)), dbody); + | Seq(e1, e2) => + Sequence(of_menhir_ast_noid(e1), of_menhir_ast_noid(e2)) + | Test(e) => + let id = getId(); + Test(id, of_menhir_ast_noid(e)); + | Cons(e1, e2) => Cons(of_menhir_ast_noid(e1), of_menhir_ast_noid(e2)) // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) }; }; diff --git a/src/haz3lcore/dynamics/DHPat.re b/src/haz3lcore/dynamics/DHPat.re index 854011dde9..9af4d4e9f1 100644 --- a/src/haz3lcore/dynamics/DHPat.re +++ b/src/haz3lcore/dynamics/DHPat.re @@ -59,6 +59,7 @@ let rec of_menhir_ast = (pat: Hazel_menhir.AST.pat): t => { | TypeAnn(pat, _typ) => of_menhir_ast(pat) | TuplePat(pats) => Tuple(List.map(of_menhir_ast, pats)) | ApPat(pat1, pat2) => Ap(of_menhir_ast(pat1), of_menhir_ast(pat2)) + | ConsPat(p1, p2) => Cons(of_menhir_ast(p1), of_menhir_ast(p2)) | BoolPat(b) => BoolLit(b) }; }; diff --git a/src/haz3lcore/dynamics/FilterAction.re b/src/haz3lcore/dynamics/FilterAction.re index 6a4dce5ca3..4324744b85 100644 --- a/src/haz3lcore/dynamics/FilterAction.re +++ b/src/haz3lcore/dynamics/FilterAction.re @@ -19,3 +19,12 @@ let string_of_t = v => { | (Eval, All) => "eval" }; }; + +let of_menhir_ast = (a: Hazel_menhir.AST.filter_action): t => { + switch (a) { + | Eval => (Eval, All) + | Pause => (Step, One) + | Debug => (Step, All) + | Hide => (Eval, One) + }; +}; diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 2a059e3826..0a45cf1a04 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -1,5 +1,12 @@ open Sexplib.Std; +[@deriving (show({with_path: false}), sexp, yojson)] +type filter_action = + | Pause + | Debug + | Hide + | Eval; + [@deriving (show({with_path: false}), sexp, yojson)] type op_bin_float = | Plus @@ -64,6 +71,7 @@ type pat = | TypeAnn(pat, typ) | TuplePat(list(pat)) | BoolPat(bool) + | ConsPat(pat, pat) | ApPat(pat, pat); [@deriving (show({with_path: false}), sexp, yojson)] @@ -91,4 +99,8 @@ type exp = | Cast(exp, typ, typ) | NonEmptyHole(exp) | EmptyHole + | Filter(filter_action, exp, exp) + | Seq(exp, exp) + | Test(exp) + | Cons(exp, exp) | If(if_consistency, exp, exp, exp); diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll index 199e295845..a41d7d20d7 100644 --- a/src/menhir-parser/Lexer.mll +++ b/src/menhir-parser/Lexer.mll @@ -82,16 +82,27 @@ rule token = | "|" { TURNSTILE } | "," { COMMA } | ":" { COLON } + (* Types *) | "Int" { INT_TYPE } | "Float" { FLOAT_TYPE } | "Bool" { BOOL_TYPE } | "String" { STRING_TYPE } | "Unknown" { UNKNOWN } | "Internal" { INTERNAL } + (* DHExp Annotations *) | "()" { UNIT } | "_FIX" {FIX} | "_FREE" {FREE} | "_HOLE" {HOLE} + (* Filters *) + | "pause" {PAUSE} + | "debug" {DEBUG} + | "hide" {HIDE} + | "eval" {EVAL} + (* Other *) + | ";" {SEMI_COLON} + | "test" {TEST} + | "::" { CONS } | identifier as i { IDENT(i) } | eof { EOF } | _ { raise (Failure ("Lex error: unknown char: '" ^ Lexing.lexeme lexbuf ^ "'")) } diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index a2d14defb0..4331b4998f 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -3,7 +3,12 @@ open AST %} - +%token CONS +%token TEST +%token PAUSE +%token DEBUG +%token HIDE +%token EVAL %token HOLE %token FREE %token FIX @@ -78,6 +83,8 @@ open AST %token THEN %token ELSE +%token SEMI_COLON + %type exp %start program @@ -150,6 +157,7 @@ pat: | TRUE { BoolPat true} | FALSE {BoolPat false} (* | p1 = pat; AS; p2 = pat; { AsPat(p1, p2) } *) + | p1 = pat; CONS; p2 = pat { ConsPat(p1, p2) } | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } @@ -175,6 +183,12 @@ ifExp: | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (Consistent, e1, e2, e3) } | HOLE; IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (Inconsistent, e1, e2, e3) } +filterAction: + | PAUSE { Pause } + | DEBUG { Debug } + | HIDE { Hide } + | EVAL { Eval } + exp: | i = INT { Int i } | f = FLOAT { Float f } @@ -196,5 +210,8 @@ exp: | FALSE { Bool false } | OPEN_PAREN; HOLE; e = exp; CLOSE_PAREN {NonEmptyHole e} | HOLE { EmptyHole } - (* | OPEN_PAREN; e = exp; CLOSE_PAREN { NonEmptyHole(e) } *) | UNIT { EmptyHole } + | a = filterAction; cond = exp; body = exp { Filter(a, cond, body)} + | TEST; e = exp; END { Test(e) } + | e1 = exp; CONS; e2 = exp { Cons(e1, e2) } + | e1 = exp; SEMI_COLON; e2 = exp { Seq(e1, e2) } diff --git a/src/test/Test_Elaboration.re b/src/test/Test_Elaboration.re index c41b923417..6b8383d22b 100644 --- a/src/test/Test_Elaboration.re +++ b/src/test/Test_Elaboration.re @@ -102,7 +102,7 @@ let f : Int -> Int = 55"; let let_fun_menhir = () => alco_check_menhir( - "Let expression for function (str elaborated using the menhir parser)", + "Let expression for a function which wraps a fix point constructor around the function", let_fun_str, let_fun_uexp, ); From 76d1ef8229af8530140d8f60bb0db1e863071cad Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 22 Apr 2024 18:06:42 -0400 Subject: [PATCH 026/281] added in the remaining pat forms & docs, cleaned up some of the code, added ids to the pats --- src/haz3lcore/dynamics/DH.re | 33 +++++++++++--------- src/haz3lcore/dynamics/DHPat.re | 53 +++++++++++++++++++++------------ src/menhir-parser/AST.re | 11 ++++++- src/menhir-parser/Lexer.mll | 8 ++++- src/menhir-parser/Parser.mly | 19 ++++++++++-- 5 files changed, 87 insertions(+), 37 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index 465ca8f872..25029a4552 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -37,13 +37,13 @@ module rec DHExp: { | BinStringOp(TermBase.UExp.op_bin_string, t, t) // | ListLit(MetaVar.t, MetaVarInst.t, Typ.t, list(t)) //[a, b, c] | Cons(t, t) //a :: b - | ListConcat(t, t) //TODO + | ListConcat(t, t) //a @ b | Tuple(list(t)) //(a, b) | Prj(t, int) //TODO - | Constructor(string) //TODO + | Constructor(string) //X | ConsistentCase(case) //4 == 3 | true => 24 | false => false end | Cast(t, Typ.t, Typ.t) //x Int> - | FailedCast(t, Typ.t, Typ.t) //TODO + | FailedCast(t, Typ.t, Typ.t) //x ? Int> | InvalidOperation(t, InvalidOperationError.t) | IfThenElse(if_consistency, t, t, t) // use bool tag to track if branches are consistent // if false then 8 else 6 @@ -353,7 +353,7 @@ module rec DHExp: { getId: bool => Id.t, ) : rule => { - Rule(DHPat.of_menhir_ast(pat), of_menhir_ast(exp, getId)); + Rule(DHPat.of_menhir_ast(pat, getId), of_menhir_ast(exp, getId)); } //whenever we assign a hole an id, make sure to increment the idIndex value and of_menhir_ast = (exp: Hazel_menhir.AST.exp, getId: bool => Id.t): t => { @@ -368,18 +368,15 @@ module rec DHExp: { | String(s) => StringLit(s) | Bool(b) => BoolLit(b) | Var(x) => BoundVar(x) + | Constructor(x) => Constructor(x) | FreeVar(x) => FreeVar(getId_no_inc(), 0, x) - | ArrayExp(l) => - ListLit( - Id.mk(), - 0, - Unknown(SynSwitch), - List.map(of_menhir_ast_noid, l), - ) + | ListExp(l, t) => + let id = getId(); + ListLit(id, 0, Typ.of_menhir_ast(t), List.map(of_menhir_ast_noid, l)); | TupleExp(t) => Tuple(List.map(of_menhir_ast_noid, t)) | Let(p, e1, e2) => Let( - DHPat.of_menhir_ast(p), + DHPat.of_menhir_ast(p, getId_all_args), of_menhir_ast_noid(e1), of_menhir_ast_noid(e2), ) @@ -387,14 +384,14 @@ module rec DHExp: { switch (name_opt) { | Some(name_str) => Fun( - DHPat.of_menhir_ast(p), + DHPat.of_menhir_ast(p, getId_all_args), Typ.of_menhir_ast(t), of_menhir_ast_noid(e), Some(name_str), ) | None => Fun( - DHPat.of_menhir_ast(p), + DHPat.of_menhir_ast(p, getId_all_args), Typ.of_menhir_ast(t), of_menhir_ast_noid(e), None, @@ -443,6 +440,12 @@ module rec DHExp: { Typ.of_menhir_ast(t1), Typ.of_menhir_ast(t2), ) + | FailedCast(e, t1, t2) => + FailedCast( + of_menhir_ast_noid(e), + Typ.of_menhir_ast(t1), + Typ.of_menhir_ast(t2), + ) | EmptyHole => EmptyHole(getId(), 0) | NonEmptyHole(e) => let id = getId(); @@ -459,6 +462,8 @@ module rec DHExp: { let id = getId(); Test(id, of_menhir_ast_noid(e)); | Cons(e1, e2) => Cons(of_menhir_ast_noid(e1), of_menhir_ast_noid(e2)) + | ListConcat(e1, e2) => + ListConcat(of_menhir_ast_noid(e1), of_menhir_ast_noid(e2)) // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) }; }; diff --git a/src/haz3lcore/dynamics/DHPat.re b/src/haz3lcore/dynamics/DHPat.re index 9af4d4e9f1..54b5c25042 100644 --- a/src/haz3lcore/dynamics/DHPat.re +++ b/src/haz3lcore/dynamics/DHPat.re @@ -2,22 +2,22 @@ open Sexplib.Std; [@deriving (show({with_path: false}), sexp, yojson)] type t = - | EmptyHole(MetaVar.t, MetaVarInst.t) - | NonEmptyHole(ErrStatus.HoleReason.t, MetaVar.t, MetaVarInst.t, t) - | Wild + | EmptyHole(MetaVar.t, MetaVarInst.t) // () or _HOLE + | NonEmptyHole(ErrStatus.HoleReason.t, MetaVar.t, MetaVarInst.t, t) //(_HOLE x) + | Wild //_ | ExpandingKeyword(MetaVar.t, MetaVarInst.t, ExpandingKeyword.t) | InvalidText(MetaVar.t, MetaVarInst.t, string) - | BadConstructor(MetaVar.t, MetaVarInst.t, string) - | Var(Var.t) - | IntLit(int) - | FloatLit(float) - | BoolLit(bool) - | StringLit(string) - | ListLit(Typ.t, list(t)) - | Cons(t, t) - | Tuple(list(t)) - | Constructor(string) - | Ap(t, t); + | BadConstructor(MetaVar.t, MetaVarInst.t, string) //_BAD x + | Var(Var.t) // x + | IntLit(int) // 1 + | FloatLit(float) //1.0 + | BoolLit(bool) // false + | StringLit(string) //"hello" + | ListLit(Typ.t, list(t)) //[a, b, c] + | Cons(t, t) //a :: b + | Tuple(list(t)) //(a, b) + | Constructor(string) //X + | Ap(t, t); //a(1) let mk_tuple: list(t) => t = fun @@ -50,17 +50,32 @@ let rec binds_var = (x: Var.t, dp: t): bool => | Ap(_, _) => false }; -let rec of_menhir_ast = (pat: Hazel_menhir.AST.pat): t => { +let rec of_menhir_ast = (pat: Hazel_menhir.AST.pat, getId: bool => Uuidm.t): t => { + let of_menhir_ast_noid = of_menhir_ast(_, getId); + // let getId_all_args = getId; + let getId_no_inc = () => getId(false); + let getId = () => getId(true); switch (pat) { | IntPat(i) => IntLit(i) | FloatPat(f) => FloatLit(f) | VarPat(x) => Var(x) + | BadConstructorPat(x) => BadConstructor(getId_no_inc(), 0, x) + | ConstructorPat(x) => Constructor(x) | StringPat(s) => StringLit(s) - | TypeAnn(pat, _typ) => of_menhir_ast(pat) - | TuplePat(pats) => Tuple(List.map(of_menhir_ast, pats)) - | ApPat(pat1, pat2) => Ap(of_menhir_ast(pat1), of_menhir_ast(pat2)) - | ConsPat(p1, p2) => Cons(of_menhir_ast(p1), of_menhir_ast(p2)) + | TypeAnn(pat, _typ) => of_menhir_ast_noid(pat) + | TuplePat(pats) => Tuple(List.map(of_menhir_ast_noid, pats)) + | ApPat(pat1, pat2) => + Ap(of_menhir_ast_noid(pat1), of_menhir_ast_noid(pat2)) + | ConsPat(p1, p2) => Cons(of_menhir_ast_noid(p1), of_menhir_ast_noid(p2)) | BoolPat(b) => BoolLit(b) + | EmptyHolePat => EmptyHole(getId(), 0) + | NonEmptyHolePat(p) => + let id = getId(); + let p = of_menhir_ast_noid(p); + NonEmptyHole(ErrStatus.HoleReason.TypeInconsistent, id, 0, p); + | WildPat => Wild + | ListPat(l, t) => + ListLit(Typ.of_menhir_ast(t), List.map(of_menhir_ast_noid, l)) }; }; diff --git a/src/menhir-parser/AST.re b/src/menhir-parser/AST.re index 0a45cf1a04..7a14191a5b 100644 --- a/src/menhir-parser/AST.re +++ b/src/menhir-parser/AST.re @@ -64,14 +64,20 @@ type typ = [@deriving (show({with_path: false}), sexp, yojson)] type pat = + | EmptyHolePat + | WildPat + | NonEmptyHolePat(pat) | IntPat(int) | FloatPat(float) | VarPat(string) + | ConstructorPat(string) + | BadConstructorPat(string) | StringPat(string) | TypeAnn(pat, typ) | TuplePat(list(pat)) | BoolPat(bool) | ConsPat(pat, pat) + | ListPat(list(pat), typ) | ApPat(pat, pat); [@deriving (show({with_path: false}), sexp, yojson)] @@ -84,9 +90,10 @@ type exp = | Int(int) | Float(float) | Var(string) + | Constructor(string) | FreeVar(string) | String(string) - | ArrayExp(list(exp)) + | ListExp(list(exp), typ) | TupleExp(list(exp)) | BinExp(exp, binOp, exp) | Let(pat, exp, exp) @@ -97,10 +104,12 @@ type exp = | ApExp(exp, exp) | Bool(bool) | Cast(exp, typ, typ) + | FailedCast(exp, typ, typ) | NonEmptyHole(exp) | EmptyHole | Filter(filter_action, exp, exp) | Seq(exp, exp) | Test(exp) | Cons(exp, exp) + | ListConcat(exp, exp) | If(if_consistency, exp, exp, exp); diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll index a41d7d20d7..70f962bbfe 100644 --- a/src/menhir-parser/Lexer.mll +++ b/src/menhir-parser/Lexer.mll @@ -21,7 +21,8 @@ let newline = '\r' | '\n' | "\r\n" let whitespace = [' ' '\t']+ -let identifier = ['a'-'z' 'A'-'Z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* +let identifier = ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* +let constructor_ident = ['A'-'Z'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* rule token = parse @@ -103,6 +104,11 @@ rule token = | ";" {SEMI_COLON} | "test" {TEST} | "::" { CONS } + | "@" {LIST_CONCAT} + | "?" {QUESTION} + | "_" {WILD} + | "_BAD" {BAD_CONSTRUCTOR} | identifier as i { IDENT(i) } + | constructor_ident as i { CONSTRUCTOR_IDENT(i)} | eof { EOF } | _ { raise (Failure ("Lex error: unknown char: '" ^ Lexing.lexeme lexbuf ^ "'")) } diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index 4331b4998f..ee3773a53c 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -3,6 +3,10 @@ open AST %} +%token BAD_CONSTRUCTOR +%token WILD +%token QUESTION +%token LIST_CONCAT %token CONS %token TEST %token PAUSE @@ -13,6 +17,7 @@ open AST %token FREE %token FIX %token IDENT +%token CONSTRUCTOR_IDENT %token STRING %token TRUE %token FALSE @@ -148,6 +153,13 @@ varPat: | i = IDENT { VarPat (i) } pat: + | OPEN_PAREN; HOLE; p = pat; CLOSE_PAREN {NonEmptyHolePat p} + | WILD { WildPat } + | HOLE { EmptyHolePat } + | UNIT { EmptyHolePat } + | BAD_CONSTRUCTOR; c = CONSTRUCTOR_IDENT {BadConstructorPat(c)} + | OPEN_SQUARE_BRACKET; l = separated_list(COMMA, pat); CLOSE_SQUARE_BRACKET; COLON; t = typ { ListPat(l, t) } + | c = CONSTRUCTOR_IDENT { ConstructorPat(c) } | p = varPat {p} | t = patTuple { t } | t = typeAnn { t } @@ -193,16 +205,18 @@ exp: | i = INT { Int i } | f = FLOAT { Float f } | v = IDENT { Var v } + | c = CONSTRUCTOR_IDENT { Constructor c } | FREE; v = IDENT { FreeVar v } | s = STRING { String s} | b = binExp { b } | OPEN_PAREN; e = exp; CLOSE_PAREN { e } - | OPEN_PAREN; l = separated_list(COMMA, exp) ; CLOSE_PAREN { TupleExp(l)} + | OPEN_PAREN; l = separated_list(COMMA, exp); CLOSE_PAREN { TupleExp(l)} | c = case { c } - | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ArrayExp(e) } + | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET; COLON; t = typ { ListExp(e, t) } | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } | i = ifExp { i} + | e1 = exp; QUESTION; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN {FailedCast(e1, t1, t2)} | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } | TRUE { Bool true } | FIX; s = IDENT; t = typ; f = funExp { FixF(s, t, f) } @@ -213,5 +227,6 @@ exp: | UNIT { EmptyHole } | a = filterAction; cond = exp; body = exp { Filter(a, cond, body)} | TEST; e = exp; END { Test(e) } + | e1 = exp; LIST_CONCAT; e2 = exp { ListConcat(e1, e2) } | e1 = exp; CONS; e2 = exp { Cons(e1, e2) } | e1 = exp; SEMI_COLON; e2 = exp { Seq(e1, e2) } From cd8ae480f383a2a5cb15f83885f8893c90b4d7e7 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 22 Apr 2024 18:46:21 -0400 Subject: [PATCH 027/281] finished fixing conflicts with the elaborator file & new tests directory, added in the plus to the fix point function name --- src/haz3lcore/dynamics/DH.re | 2 +- test/Test_Elaboration.re | 14 -------------- test/Test_Menhir.re | 2 +- 3 files changed, 2 insertions(+), 16 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index 41670b5f17..d922c88773 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -395,7 +395,7 @@ module rec DHExp: { DHPat.of_menhir_ast(p, getId_all_args), Typ.of_menhir_ast(t), of_menhir_ast_noid(e), - Some(name_str), + Some(name_str ++ "+"), ) | None => Fun( diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 4e099759f4..6b8383d22b 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -93,7 +93,6 @@ let let_fun_uexp: Term.UExp.t = { {ids: [id_at(11)], term: Int(55)}, ), }; -<<<<<<< HEAD:src/test/Test_Elaboration.re let let_fun_str = " let f : Int -> Int = _FIX f Int -> Int fun: Int x -> @@ -130,19 +129,6 @@ let free_var_menhir = () => Haz3lcore.DHExp.of_menhir_ast( Hazel_menhir.Interface.parse_program("(_HOLE _FREE y)"), get_id_menhir_closure(1), -======= -let d9: DHExp.t = - Let( - Var("f"), - FixF( - "f", - Arrow(Int, Int), - Fun( - Var("x"), - Int, - BinIntOp(Plus, IntLit(1), BoundVar("x")), - Some("f+"), ->>>>>>> dev:test/Test_Elaboration.re ), ), dhexp_of_uexp(free_var_uexp), diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index c2fc70e984..aab49b1279 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -2,7 +2,7 @@ open Hazel_menhir; // open Haz3lcore.DHExp; open Alcotest; -let test_file = "./src/test/test.hazel"; +let test_file = "./test/test.hazel"; let read_whole_file = (filename): string => { let ch = open_in_bin(filename); From a33b30daa44d973b8ca37fd5a67ac9fa5283a945 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 26 Apr 2024 00:13:38 -0400 Subject: [PATCH 028/281] changed the hole syntax to align with Cyrus comments; changed menhir dh docs to use metavariables --- src/haz3lcore/dynamics/DH.re | 48 ++++++++++++++++++------------------ src/menhir-parser/Lexer.mll | 3 --- src/menhir-parser/Parser.mly | 17 +++++-------- 3 files changed, 30 insertions(+), 38 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index d922c88773..e25648e420 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -7,49 +7,49 @@ type if_consistency = | InconsistentIf; module rec DHExp: { - //All comments show the textual syntax for DHExp when built using the menhir parser + //All comments show the textual syntax for DHExp when built using the menhir parser. e = exp; p = pat; t = typ [@deriving (show({with_path: false}), sexp, yojson)] type t = - | EmptyHole(MetaVar.t, HoleInstanceId.t) //() - | NonEmptyHole(ErrStatus.HoleReason.t, MetaVar.t, HoleInstanceId.t, t) //(_HOLE x) - | FreeVar(MetaVar.t, HoleInstanceId.t, Var.t) //(_FREE x) + | EmptyHole(MetaVar.t, HoleInstanceId.t) //? + | NonEmptyHole(ErrStatus.HoleReason.t, MetaVar.t, HoleInstanceId.t, t) //{{e}} + | FreeVar(MetaVar.t, HoleInstanceId.t, Var.t) //{{?e}} | InvalidText(MetaVar.t, HoleInstanceId.t, string) - | InconsistentBranches(MetaVar.t, HoleInstanceId.t, case) //(_HOLE (case ...)) + | InconsistentBranches(MetaVar.t, HoleInstanceId.t, case) //{{? case ...}} | Closure([@opaque] ClosureEnvironment.t, t) | Filter(DHFilter.t, t) //pause a == 2 b - | BoundVar(Var.t) //x - | Sequence(t, t) //a; b - | Let(DHPat.t, t, t) //let x = y in z + | BoundVar(Var.t) //e + | Sequence(t, t) //e1; e2 + | Let(DHPat.t, t, t) //let p = e1 in e2 | FixF(Var.t, Typ.t, t) //_FIX f Int -> Int fun: Int x -> 1 + x f in 55 - | Fun(DHPat.t, Typ.t, t, option(Var.t)) //fun: Int x -> x + 1 + | Fun(DHPat.t, Typ.t, t, option(Var.t)) //fun: t p -> e | TypFun(Term.UTPat.t, t, option(Var.t)) | TypAp(t, Typ.t) - | Ap(t, t) //a(1) + | Ap(t, t) //e1(e2) | ApBuiltin(string, t) | BuiltinFun(string) - | Test(KeywordID.t, t) //test a end + | Test(KeywordID.t, t) //test e end | BoolLit(bool) //true | IntLit(int) //1 | FloatLit(float) //1.0 | StringLit(string) //"hello" - | BinBoolOp(TermBase.UExp.op_bin_bool, t, t) //true && false - | BinIntOp(TermBase.UExp.op_bin_int, t, t) //1 + 2 - | BinFloatOp(TermBase.UExp.op_bin_float, t, t) //1 +. 2 + | BinBoolOp(TermBase.UExp.op_bin_bool, t, t) //e1 && e2 + | BinIntOp(TermBase.UExp.op_bin_int, t, t) //e1 + e2 + | BinFloatOp(TermBase.UExp.op_bin_float, t, t) //e1 +. e2 | BinStringOp(TermBase.UExp.op_bin_string, t, t) // - | ListLit(MetaVar.t, MetaVarInst.t, Typ.t, list(t)) //[a, b, c] - | Cons(t, t) //a :: b - | ListConcat(t, t) //a @ b - | Tuple(list(t)) //(a, b) + | ListLit(MetaVar.t, MetaVarInst.t, Typ.t, list(t)) //[e1, e2, e3] + | Cons(t, t) //e1 :: e2 + | ListConcat(t, t) //e1 @ e2 + | Tuple(list(t)) //(e1, e2) | Prj(t, int) //TODO - | Constructor(string) //X - | ConsistentCase(case) //4 == 3 | true => 24 | false => false end - | Cast(t, Typ.t, Typ.t) //x Int> - | FailedCast(t, Typ.t, Typ.t) //x ? Int> + | Constructor(string) //E (expression must be capitalized) + | ConsistentCase(case) //e1 | p1 => e2 | p2 => e2 end + | Cast(t, Typ.t, Typ.t) //e t2> + | FailedCast(t, Typ.t, Typ.t) //e ? t2> | InvalidOperation(t, InvalidOperationError.t) | IfThenElse(if_consistency, t, t, t) // use bool tag to track if branches are consistent - // if false then 8 else 6 + // if e1 then e2 else e3 and case = - | Case(t, list(rule), int) //4 == 3 | true => 24 | false => false end + | Case(t, list(rule), int) //e1 | p1 => e2 | p2 => e2 end and rule = | Rule(DHPat.t, t); diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll index 70f962bbfe..9e02069614 100644 --- a/src/menhir-parser/Lexer.mll +++ b/src/menhir-parser/Lexer.mll @@ -92,9 +92,6 @@ rule token = | "Internal" { INTERNAL } (* DHExp Annotations *) | "()" { UNIT } - | "_FIX" {FIX} - | "_FREE" {FREE} - | "_HOLE" {HOLE} (* Filters *) | "pause" {PAUSE} | "debug" {DEBUG} diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index ee3773a53c..ad7c21ca87 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -13,9 +13,6 @@ open AST %token DEBUG %token HIDE %token EVAL -%token HOLE -%token FREE -%token FIX %token IDENT %token CONSTRUCTOR_IDENT %token STRING @@ -153,10 +150,9 @@ varPat: | i = IDENT { VarPat (i) } pat: - | OPEN_PAREN; HOLE; p = pat; CLOSE_PAREN {NonEmptyHolePat p} + | OPEN_BRACKET; OPEN_BRACKET; p = pat; CLOSE_BRACKET; CLOSE_BRACKET; {NonEmptyHolePat p} | WILD { WildPat } - | HOLE { EmptyHolePat } - | UNIT { EmptyHolePat } + | QUESTION { EmptyHolePat } | BAD_CONSTRUCTOR; c = CONSTRUCTOR_IDENT {BadConstructorPat(c)} | OPEN_SQUARE_BRACKET; l = separated_list(COMMA, pat); CLOSE_SQUARE_BRACKET; COLON; t = typ { ListPat(l, t) } | c = CONSTRUCTOR_IDENT { ConstructorPat(c) } @@ -184,7 +180,7 @@ rul: case: | CASE; e = exp; l = list(rul); END; { CaseExp(e, l) } - | OPEN_PAREN; CASE; e = exp; l = list(rul); END; CLOSE_PAREN { InconsistentCaseExp(e, l)} + | OPEN_BRACKET; OPEN_BRACKET; QUESTION; e = exp; l = list(rul); END; CLOSE_BRACKET; CLOSE_BRACKET { InconsistentCaseExp(e, l)} funExp: | FUN; COLON; t = typ; p = pat; DASH_ARROW; e1 = exp; { Fun (t, p, e1, None) } @@ -206,7 +202,7 @@ exp: | f = FLOAT { Float f } | v = IDENT { Var v } | c = CONSTRUCTOR_IDENT { Constructor c } - | FREE; v = IDENT { FreeVar v } + | OPEN_BRACKET; OPEN_BRACKET; QUESTION; v = IDENT CLOSE_BRACKET; CLOSE_BRACKET; { FreeVar v } | s = STRING { String s} | b = binExp { b } | OPEN_PAREN; e = exp; CLOSE_PAREN { e } @@ -222,9 +218,8 @@ exp: | FIX; s = IDENT; t = typ; f = funExp { FixF(s, t, f) } | f = funExp {f} | FALSE { Bool false } - | OPEN_PAREN; HOLE; e = exp; CLOSE_PAREN {NonEmptyHole e} - | HOLE { EmptyHole } - | UNIT { EmptyHole } + | OPEN_BRACKET; OPEN_BRACKET; e = exp; CLOSE_BRACKET; CLOSE_BRACKET {NonEmptyHole e} + | QUESTION { EmptyHole } | a = filterAction; cond = exp; body = exp { Filter(a, cond, body)} | TEST; e = exp; END { Test(e) } | e1 = exp; LIST_CONCAT; e2 = exp { ListConcat(e1, e2) } From 27be64a2086d830c29f0d8ee14fb0eb9a9d57d2f Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 27 May 2024 18:44:58 -0400 Subject: [PATCH 029/281] fixed parser build error, updated DHPat and Typ docs to new menhir textual syntax, fixed menhir conflict with fixf --- src/haz3lcore/dynamics/DH.re | 2 +- src/haz3lcore/dynamics/DHPat.re | 17 +++++++++-------- src/haz3lcore/statics/TypBase.re | 15 ++++++++------- src/menhir-parser/Lexer.mll | 1 + src/menhir-parser/Parser.mly | 5 +++-- 5 files changed, 22 insertions(+), 18 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index e25648e420..fe58341bad 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -20,7 +20,7 @@ module rec DHExp: { | BoundVar(Var.t) //e | Sequence(t, t) //e1; e2 | Let(DHPat.t, t, t) //let p = e1 in e2 - | FixF(Var.t, Typ.t, t) //_FIX f Int -> Int fun: Int x -> 1 + x f in 55 + | FixF(Var.t, Typ.t, t) //fix x : ty => e | Fun(DHPat.t, Typ.t, t, option(Var.t)) //fun: t p -> e | TypFun(Term.UTPat.t, t, option(Var.t)) | TypAp(t, Typ.t) diff --git a/src/haz3lcore/dynamics/DHPat.re b/src/haz3lcore/dynamics/DHPat.re index f930b0e385..4524daf3e8 100644 --- a/src/haz3lcore/dynamics/DHPat.re +++ b/src/haz3lcore/dynamics/DHPat.re @@ -1,22 +1,23 @@ open Sexplib.Std; +//Below comments show the textual syntax to build a DHPat whe nusing the menhir parser [@deriving (show({with_path: false}), sexp, yojson)] type t = - | EmptyHole(MetaVar.t, MetaVarInst.t) // () or _HOLE - | NonEmptyHole(ErrStatus.HoleReason.t, MetaVar.t, MetaVarInst.t, t) //(_HOLE x) + | EmptyHole(MetaVar.t, MetaVarInst.t) // ? + | NonEmptyHole(ErrStatus.HoleReason.t, MetaVar.t, MetaVarInst.t, t) //{{p}} | Wild //_ | InvalidText(MetaVar.t, MetaVarInst.t, string) | BadConstructor(MetaVar.t, MetaVarInst.t, string) //_BAD x - | Var(Var.t) // x + | Var(Var.t) // p | IntLit(int) // 1 | FloatLit(float) //1.0 | BoolLit(bool) // false | StringLit(string) //"hello" - | ListLit(Typ.t, list(t)) //[a, b, c] - | Cons(t, t) //a :: b - | Tuple(list(t)) //(a, b) - | Constructor(string) //X - | Ap(t, t); //a(1) + | ListLit(Typ.t, list(t)) //[p1, p2, p3] + | Cons(t, t) //p1 :: p2 + | Tuple(list(t)) //(p1, p2) + | Constructor(string) //P (must be capitalized) + | Ap(t, t); //p1(p2) let mk_tuple: list(t) => t = fun diff --git a/src/haz3lcore/statics/TypBase.re b/src/haz3lcore/statics/TypBase.re index 6433dc3406..f610544f7b 100644 --- a/src/haz3lcore/statics/TypBase.re +++ b/src/haz3lcore/statics/TypBase.re @@ -21,16 +21,17 @@ module rec Typ: { | Internal; /* TYP.T: Hazel types */ + //Commens show the textual syntax for Typ when using the Menhir parser. [@deriving (show({with_path: false}), sexp, yojson)] type t = - | Unknown(type_provenance) - | Int - | Float - | Bool - | String + | Unknown(type_provenance) //Unknown type_provenance + | Int //Int + | Float //Float + | Bool //Bool + | String //String | Var(TypVar.t) - | List(t) - | Arrow(t, t) + | List(t) //(t1, t2 ...) + | Arrow(t, t) //t1 -> t2 | Sum(sum_map) | Prod(list(t)) | Rec(TypVar.t, t) diff --git a/src/menhir-parser/Lexer.mll b/src/menhir-parser/Lexer.mll index 9e02069614..420fd5822e 100644 --- a/src/menhir-parser/Lexer.mll +++ b/src/menhir-parser/Lexer.mll @@ -105,6 +105,7 @@ rule token = | "?" {QUESTION} | "_" {WILD} | "_BAD" {BAD_CONSTRUCTOR} + | "fix" {FIX} | identifier as i { IDENT(i) } | constructor_ident as i { CONSTRUCTOR_IDENT(i)} | eof { EOF } diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index ad7c21ca87..46782914ec 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -3,6 +3,7 @@ open AST %} +%token FIX %token BAD_CONSTRUCTOR %token WILD %token QUESTION @@ -189,7 +190,7 @@ funExp: ifExp: | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (Consistent, e1, e2, e3) } - | HOLE; IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (Inconsistent, e1, e2, e3) } + | OPEN_BRACKET; OPEN_BRACKET; QUESTION; IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp; CLOSE_BRACKET; CLOSE_BRACKET { If (Inconsistent, e1, e2, e3) } filterAction: | PAUSE { Pause } @@ -215,7 +216,7 @@ exp: | e1 = exp; QUESTION; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN {FailedCast(e1, t1, t2)} | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } | TRUE { Bool true } - | FIX; s = IDENT; t = typ; f = funExp { FixF(s, t, f) } + | FIX; s = IDENT; COLON; t = typ; EQUAL_ARROW; e = exp { FixF(s, t, e) } | f = funExp {f} | FALSE { Bool false } | OPEN_BRACKET; OPEN_BRACKET; e = exp; CLOSE_BRACKET; CLOSE_BRACKET {NonEmptyHole e} From 971945c0c2fb9702012d6cfc0b21c88aa484924d Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 27 May 2024 19:02:30 -0400 Subject: [PATCH 030/281] updated menhir elaboration unit tests to new menhir dhexp syntax --- src/haz3lcore/dynamics/DH.re | 2 +- src/haz3lcore/statics/TypBase.re | 2 +- src/menhir-parser/Parser.mly | 5 +++-- test/Test_Elaboration.re | 16 +++++++--------- 4 files changed, 12 insertions(+), 13 deletions(-) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index fe58341bad..eb78af0313 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -12,7 +12,7 @@ module rec DHExp: { type t = | EmptyHole(MetaVar.t, HoleInstanceId.t) //? | NonEmptyHole(ErrStatus.HoleReason.t, MetaVar.t, HoleInstanceId.t, t) //{{e}} - | FreeVar(MetaVar.t, HoleInstanceId.t, Var.t) //{{?e}} + | FreeVar(MetaVar.t, HoleInstanceId.t, Var.t) //?e | InvalidText(MetaVar.t, HoleInstanceId.t, string) | InconsistentBranches(MetaVar.t, HoleInstanceId.t, case) //{{? case ...}} | Closure([@opaque] ClosureEnvironment.t, t) diff --git a/src/haz3lcore/statics/TypBase.re b/src/haz3lcore/statics/TypBase.re index f610544f7b..d821a6f3be 100644 --- a/src/haz3lcore/statics/TypBase.re +++ b/src/haz3lcore/statics/TypBase.re @@ -21,7 +21,7 @@ module rec Typ: { | Internal; /* TYP.T: Hazel types */ - //Commens show the textual syntax for Typ when using the Menhir parser. + //Commens show the textual syntax for Typ when using the Menhir parser. [@deriving (show({with_path: false}), sexp, yojson)] type t = | Unknown(type_provenance) //Unknown type_provenance diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index 46782914ec..8e5e8a1c9b 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -181,7 +181,8 @@ rul: case: | CASE; e = exp; l = list(rul); END; { CaseExp(e, l) } - | OPEN_BRACKET; OPEN_BRACKET; QUESTION; e = exp; l = list(rul); END; CLOSE_BRACKET; CLOSE_BRACKET { InconsistentCaseExp(e, l)} + (* | OPEN_BRACKET; OPEN_BRACKET; QUESTION; CASE; e = exp; l = list(rul); END; CLOSE_BRACKET; CLOSE_BRACKET { InconsistentCaseExp(e, l)} *) + | QUESTION; CASE; e = exp; l = list(rul); END; { InconsistentCaseExp(e, l)} funExp: | FUN; COLON; t = typ; p = pat; DASH_ARROW; e1 = exp; { Fun (t, p, e1, None) } @@ -203,7 +204,7 @@ exp: | f = FLOAT { Float f } | v = IDENT { Var v } | c = CONSTRUCTOR_IDENT { Constructor c } - | OPEN_BRACKET; OPEN_BRACKET; QUESTION; v = IDENT CLOSE_BRACKET; CLOSE_BRACKET; { FreeVar v } + | QUESTION; v = IDENT { FreeVar v } | s = STRING { String s} | b = binExp { b } | OPEN_PAREN; e = exp; CLOSE_PAREN { e } diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 6b8383d22b..b5a7de2f34 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -95,7 +95,7 @@ let let_fun_uexp: Term.UExp.t = { }; let let_fun_str = " let f : Int -> Int = - _FIX f Int -> Int fun: Int x -> + fix f: Int -> Int => fun: Int x -> 1 + x f in @@ -108,7 +108,7 @@ let let_fun_menhir = () => ); //Test for an empty hole -let empty_hole_str = "()"; +let empty_hole_str = "?"; let empty_hole_uexp: Term.UExp.t = {ids: [id_at(0)], term: EmptyHole}; let empty_hole_menhir = () => alco_check_menhir( @@ -127,7 +127,7 @@ let free_var_menhir = () => "Nonempty hole with free variable (menhir)", Some( Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program("(_HOLE _FREE y)"), + Hazel_menhir.Interface.parse_program("{{?y}}"), get_id_menhir_closure(1), ), ), @@ -149,9 +149,7 @@ let bin_op_menhir = () => "Inconsistent binary integer operation (plus)", Some( Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program( - "(_HOLE false) + (_HOLE _FREE y)", - ), + Hazel_menhir.Interface.parse_program("{{false}} + {{? y}}"), get_id_menhir_closure(1), ), ), @@ -160,10 +158,10 @@ let bin_op_menhir = () => //Inconsistent branches menhir test let inconsistent_case_menhir_str = " - (_HOLE (case 4 == 3 + {{?case 4 == 3 | true => 24 | false => false - end) ) + end}} "; let inconsistent_case_uexp: Term.UExp.t = { ids: [id_at(0)], @@ -222,7 +220,7 @@ let ap_fun_uexp: Term.UExp.t = { ), }; let ap_fun_str = " - (fun: Unknown Internal x -> 4 + x Int>)((_HOLE _FREE y)) + (fun: Unknown Internal x -> 4 + x Int>)({{? y}}) "; let ap_fun_menhir = () => alco_check( From d9d07f9a5a475201f025ff1ed0a046906f6eda48 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 27 May 2024 22:48:05 -0400 Subject: [PATCH 031/281] changed the fixf to match hazel syntax without menhir conflict --- src/menhir-parser/Parser.mly | 2 +- test/Test_Elaboration.re | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/menhir-parser/Parser.mly b/src/menhir-parser/Parser.mly index 8e5e8a1c9b..fb82ffe0cd 100644 --- a/src/menhir-parser/Parser.mly +++ b/src/menhir-parser/Parser.mly @@ -217,7 +217,7 @@ exp: | e1 = exp; QUESTION; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN {FailedCast(e1, t1, t2)} | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } | TRUE { Bool true } - | FIX; s = IDENT; COLON; t = typ; EQUAL_ARROW; e = exp { FixF(s, t, e) } + | FIX; OPEN_PAREN; s = IDENT; COLON; t = typ; CLOSE_PAREN; DASH_ARROW; e = exp { FixF(s, t, e) } | f = funExp {f} | FALSE { Bool false } | OPEN_BRACKET; OPEN_BRACKET; e = exp; CLOSE_BRACKET; CLOSE_BRACKET {NonEmptyHole e} diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index b5a7de2f34..94feee0a94 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -95,7 +95,7 @@ let let_fun_uexp: Term.UExp.t = { }; let let_fun_str = " let f : Int -> Int = - fix f: Int -> Int => fun: Int x -> + fix (f: Int -> Int) -> fun: Int x -> 1 + x f in From cc2b5dc2b7fb24d081cf76be61af45bcc2cb8455 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 7 Jun 2024 10:22:43 -0400 Subject: [PATCH 032/281] renamed the menhir parser to match hazel naming conventions --- src/haz3lcore/dune | 2 +- src/haz3lcore/dynamics/DH.re | 8 ++++---- src/haz3lcore/dynamics/DHPat.re | 2 +- src/haz3lcore/dynamics/FilterAction.re | 2 +- src/haz3lcore/statics/TermBase.re | 12 ++++++------ src/haz3lcore/statics/TypBase.re | 6 +++--- src/{menhir-parser => haz3lmenhir}/AST.re | 0 src/{menhir-parser => haz3lmenhir}/Interface.re | 0 src/{menhir-parser => haz3lmenhir}/Lexer.mll | 0 src/{menhir-parser => haz3lmenhir}/Parser.mly | 0 src/{menhir-parser => haz3lmenhir}/dune | 2 +- test/Test_Menhir.re | 2 +- test/dune | 2 +- 13 files changed, 19 insertions(+), 19 deletions(-) rename src/{menhir-parser => haz3lmenhir}/AST.re (100%) rename src/{menhir-parser => haz3lmenhir}/Interface.re (100%) rename src/{menhir-parser => haz3lmenhir}/Lexer.mll (100%) rename src/{menhir-parser => haz3lmenhir}/Parser.mly (100%) rename src/{menhir-parser => haz3lmenhir}/dune (89%) diff --git a/src/haz3lcore/dune b/src/haz3lcore/dune index 620b5cd7b9..bc3268552b 100644 --- a/src/haz3lcore/dune +++ b/src/haz3lcore/dune @@ -2,7 +2,7 @@ (library (name haz3lcore) - (libraries util re sexplib unionFind uuidm hazel_menhir) + (libraries util re sexplib unionFind uuidm haz3lmenhir) (js_of_ocaml (flags (:include js-of-ocaml-flags-%{profile}))) diff --git a/src/haz3lcore/dynamics/DH.re b/src/haz3lcore/dynamics/DH.re index eb78af0313..3c2deda8a4 100644 --- a/src/haz3lcore/dynamics/DH.re +++ b/src/haz3lcore/dynamics/DH.re @@ -1,5 +1,5 @@ open Sexplib.Std; -open Hazel_menhir.AST; +open Haz3lmenhir.AST; [@deriving (show({with_path: false}), sexp, yojson)] type if_consistency = @@ -64,7 +64,7 @@ module rec DHExp: { let fast_equal: (t, t) => bool; - let of_menhir_ast: (Hazel_menhir.AST.exp, bool => Uuidm.t) => t; + let of_menhir_ast: (Haz3lmenhir.AST.exp, bool => Uuidm.t) => t; let assign_name_if_none: (t, option(Var.t)) => t; let ty_subst: (Typ.t, TypVar.t, t) => t; } = { @@ -357,14 +357,14 @@ module rec DHExp: { let rec rule_of_menhir_ast = ( - (pat: Hazel_menhir.AST.pat, exp: Hazel_menhir.AST.exp), + (pat: Haz3lmenhir.AST.pat, exp: Haz3lmenhir.AST.exp), getId: bool => Id.t, ) : rule => { Rule(DHPat.of_menhir_ast(pat, getId), of_menhir_ast(exp, getId)); } //whenever we assign a hole an id, make sure to increment the idIndex value - and of_menhir_ast = (exp: Hazel_menhir.AST.exp, getId: bool => Id.t): t => { + and of_menhir_ast = (exp: Haz3lmenhir.AST.exp, getId: bool => Id.t): t => { let of_menhir_ast_noid = of_menhir_ast(_, getId); let getId_all_args = getId; let getId_no_inc = () => getId(false); diff --git a/src/haz3lcore/dynamics/DHPat.re b/src/haz3lcore/dynamics/DHPat.re index 4524daf3e8..cca3a54d39 100644 --- a/src/haz3lcore/dynamics/DHPat.re +++ b/src/haz3lcore/dynamics/DHPat.re @@ -49,7 +49,7 @@ let rec binds_var = (x: Var.t, dp: t): bool => | Ap(_, _) => false }; -let rec of_menhir_ast = (pat: Hazel_menhir.AST.pat, getId: bool => Uuidm.t): t => { +let rec of_menhir_ast = (pat: Haz3lmenhir.AST.pat, getId: bool => Uuidm.t): t => { let of_menhir_ast_noid = of_menhir_ast(_, getId); // let getId_all_args = getId; let getId_no_inc = () => getId(false); diff --git a/src/haz3lcore/dynamics/FilterAction.re b/src/haz3lcore/dynamics/FilterAction.re index 4324744b85..8b57f4994b 100644 --- a/src/haz3lcore/dynamics/FilterAction.re +++ b/src/haz3lcore/dynamics/FilterAction.re @@ -20,7 +20,7 @@ let string_of_t = v => { }; }; -let of_menhir_ast = (a: Hazel_menhir.AST.filter_action): t => { +let of_menhir_ast = (a: Haz3lmenhir.AST.filter_action): t => { switch (a) { | Eval => (Eval, All) | Pause => (Step, One) diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index 0afe3150d5..be8aad04d6 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -182,9 +182,9 @@ and UExp: { let float_op_to_string: op_bin_float => string; let string_op_to_string: op_bin_string => string; - let int_op_of_menhir_ast: Hazel_menhir.AST.op_bin_int => op_bin_int; - let bool_op_of_menhir_ast: Hazel_menhir.AST.op_bin_bool => op_bin_bool; - let float_op_of_menhir_ast: Hazel_menhir.AST.op_bin_float => op_bin_float; + let int_op_of_menhir_ast: Haz3lmenhir.AST.op_bin_int => op_bin_int; + let bool_op_of_menhir_ast: Haz3lmenhir.AST.op_bin_bool => op_bin_bool; + let float_op_of_menhir_ast: Haz3lmenhir.AST.op_bin_float => op_bin_float; } = { [@deriving (show({with_path: false}), sexp, yojson)] type op_un_bool = @@ -281,7 +281,7 @@ and UExp: { | Match; [@deriving (show({with_path: false}), sexp, yojson)] - let int_op_of_menhir_ast = (op: Hazel_menhir.AST.op_bin_int): op_bin_int => { + let int_op_of_menhir_ast = (op: Haz3lmenhir.AST.op_bin_int): op_bin_int => { switch (op) { | Plus => Plus | Minus => Minus @@ -299,7 +299,7 @@ and UExp: { [@deriving (show({with_path: false}), sexp, yojson)] let float_op_of_menhir_ast = - (op: Hazel_menhir.AST.op_bin_float): op_bin_float => { + (op: Haz3lmenhir.AST.op_bin_float): op_bin_float => { switch (op) { | Plus => Plus | Minus => Minus @@ -316,7 +316,7 @@ and UExp: { }; [@deriving (show({with_path: false}), sexp, yojson)] - let bool_op_of_menhir_ast = (op: Hazel_menhir.AST.op_bin_bool): op_bin_bool => { + let bool_op_of_menhir_ast = (op: Haz3lmenhir.AST.op_bin_bool): op_bin_bool => { switch (op) { | And => And | Or => Or diff --git a/src/haz3lcore/statics/TypBase.re b/src/haz3lcore/statics/TypBase.re index d821a6f3be..cd9de291ba 100644 --- a/src/haz3lcore/statics/TypBase.re +++ b/src/haz3lcore/statics/TypBase.re @@ -1,7 +1,7 @@ open Sexplib.Std; open Util; open OptUtil.Syntax; -open Hazel_menhir.AST; +open Haz3lmenhir.AST; let precedence_Prod = 1; let precedence_Arrow = 2; @@ -74,7 +74,7 @@ module rec Typ: { let get_sum_constructors: (Ctx.t, t) => option(sum_map); let is_unknown: t => bool; - let of_menhir_ast: Hazel_menhir.AST.typ => t; + let of_menhir_ast: Haz3lmenhir.AST.typ => t; let needs_parens: t => bool; let pretty_print: t => string; } = { @@ -484,7 +484,7 @@ module rec Typ: { | _ => false }; - let rec of_menhir_ast = (typ: Hazel_menhir.AST.typ): t => { + let rec of_menhir_ast = (typ: Haz3lmenhir.AST.typ): t => { switch (typ) { | IntType => Int | FloatType => Float diff --git a/src/menhir-parser/AST.re b/src/haz3lmenhir/AST.re similarity index 100% rename from src/menhir-parser/AST.re rename to src/haz3lmenhir/AST.re diff --git a/src/menhir-parser/Interface.re b/src/haz3lmenhir/Interface.re similarity index 100% rename from src/menhir-parser/Interface.re rename to src/haz3lmenhir/Interface.re diff --git a/src/menhir-parser/Lexer.mll b/src/haz3lmenhir/Lexer.mll similarity index 100% rename from src/menhir-parser/Lexer.mll rename to src/haz3lmenhir/Lexer.mll diff --git a/src/menhir-parser/Parser.mly b/src/haz3lmenhir/Parser.mly similarity index 100% rename from src/menhir-parser/Parser.mly rename to src/haz3lmenhir/Parser.mly diff --git a/src/menhir-parser/dune b/src/haz3lmenhir/dune similarity index 89% rename from src/menhir-parser/dune rename to src/haz3lmenhir/dune index 556d0d6960..0dbb862857 100644 --- a/src/menhir-parser/dune +++ b/src/haz3lmenhir/dune @@ -1,5 +1,5 @@ (library - (name hazel_menhir) + (name haz3lmenhir) (libraries util re sexplib unionFind) (preprocess (pps ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index aab49b1279..90c0e7945c 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -1,4 +1,4 @@ -open Hazel_menhir; +open Haz3lmenhir; // open Haz3lcore.DHExp; open Alcotest; diff --git a/test/dune b/test/dune index 0639bdc35f..38823aef07 100644 --- a/test/dune +++ b/test/dune @@ -9,7 +9,7 @@ base ptmap incr_dom - hazel_menhir + haz3lmenhir junit junit_alcotest) (modes js) From 4aed0bc110042d6b6db169f5c9bbc7d3692f0a09 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 7 Jun 2024 10:34:10 -0400 Subject: [PATCH 033/281] updated elaboration tests to the new menhir parser module name --- test/Test_Elaboration.re | 11 +++++------ test/Test_Menhir.re | 6 +++--- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 94feee0a94..f3448552d0 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -1,6 +1,5 @@ open Alcotest; open Haz3lcore; -// open Hazel_menhir; let dhexp_eq = (d1: option(DHExp.t), d2: option(DHExp.t)): bool => switch (d1, d2) { @@ -47,7 +46,7 @@ let alco_check_menhir = (name: string, dhexp: string, uexp: Term.UExp.t) => name, Some( Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program(dhexp), + Haz3lmenhir.Interface.parse_program(dhexp), get_id_menhir_closure(0), ), ), @@ -127,7 +126,7 @@ let free_var_menhir = () => "Nonempty hole with free variable (menhir)", Some( Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program("{{?y}}"), + Haz3lmenhir.Interface.parse_program("{{?y}}"), get_id_menhir_closure(1), ), ), @@ -149,7 +148,7 @@ let bin_op_menhir = () => "Inconsistent binary integer operation (plus)", Some( Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program("{{false}} + {{? y}}"), + Haz3lmenhir.Interface.parse_program("{{false}} + {{? y}}"), get_id_menhir_closure(1), ), ), @@ -227,7 +226,7 @@ let ap_fun_menhir = () => "Application of a function of a free variable wrapped inside a nonempty hole constructor (menhir)", Some( Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program(ap_fun_str), + Haz3lmenhir.Interface.parse_program(ap_fun_str), get_id_menhir_closure(6), ), ), @@ -252,7 +251,7 @@ let consistent_if_menhir = () => "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", Some( Haz3lcore.DHExp.of_menhir_ast( - Hazel_menhir.Interface.parse_program(consistent_if_str), + Haz3lmenhir.Interface.parse_program(consistent_if_str), get_id_menhir_closure(6), ), ), diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 90c0e7945c..dc9e3d7bb2 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -13,9 +13,9 @@ let read_whole_file = (filename): string => { let file_contents = read_whole_file(test_file); -// print_endline(AST.show_exp(Hazel_menhir.Interface.parse_program(file_contents))); +// print_endline(AST.show_exp(Haz3lmenhir.Interface.parse_program(file_contents))); -// let prog: AST.exp = Hazel_menhir.Interface.parse_program(file_contents); +// let prog: AST.exp = Haz3lmenhir.Interface.parse_program(file_contents); // let dhexp = of_menhir_ast(prog); // print_endline(show(dhexp)); @@ -30,7 +30,7 @@ let parser_test = (a, expected, actual, ()) => testable_ast, a, expected, - Hazel_menhir.Interface.parse_program(actual), + Haz3lmenhir.Interface.parse_program(actual), ); // let bigger_expression = From 56ceaf862dcaa96d18e89d5065c7654f9b06278c Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 28 Jun 2024 15:19:54 -0400 Subject: [PATCH 034/281] updated elaborator tests to use the new unified Exp menhir parser --- test/Test_Elaboration.re | 559 +++++++++++---------------------------- test/Test_Menhir.re | 44 +-- test/haz3ltest.re | 4 +- 3 files changed, 173 insertions(+), 434 deletions(-) diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index b1563a344f..6d9bcb0b69 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -29,366 +29,99 @@ let mk_map = CoreSettings.on |> Interface.Statics.mk_map; let dhexp_of_uexp = u => Elaborator.elaborate(mk_map(u), u) |> fst; let alco_check = dhexp_typ |> Alcotest.check; -// let alco_check_menhir = (name: string, dhexp: string, uexp: Term.Exp.t) => -// alco_check( -// name, -// Some( -// Haz3lcore.TermBase.Exp.of_menhir_ast( -// Haz3lmenhir.Interface.parse_program(dhexp), -// get_id_menhir_closure(0), -// ), -// ), -// dhexp_of_uexp(uexp), -// ); -// -// //Test for a let function -// let let_fun_uexp: Term.UExp.t = { -// ids: [id_at(0)], -// term: -// Let( -// { -// ids: [id_at(1)], -// term: -// TypeAnn( -// {ids: [id_at(2)], term: Var("f")}, -// { -// ids: [id_at(3)], -// term: -// Arrow( -// {ids: [id_at(4)], term: Int}, -// {ids: [id_at(5)], term: Int}, -// ), -// }, -// ), -// }, -// { -// ids: [id_at(6)], -// term: -// Fun( -// {ids: [id_at(7)], term: Var("x")}, -// { -// ids: [id_at(8)], -// term: -// BinOp( -// Int(Plus), -// {ids: [id_at(9)], term: Int(1)}, -// {ids: [id_at(10)], term: Var("x")}, -// ), -// }, -// ), -// }, -// {ids: [id_at(11)], term: Int(55)}, -// ), -// }; -// let let_fun_str = " -// let f : Int -> Int = -// fix (f: Int -> Int) -> fun: Int x -> -// 1 + x -// f -// in -// 55"; -// let let_fun_menhir = () => -// alco_check_menhir( -// "Let expression for a function which wraps a fix point constructor around the function", -// let_fun_str, -// let_fun_uexp, -// ); -// -// //Test for an empty hole -// let empty_hole_str = "?"; -// let empty_hole_uexp: Term.UExp.t = {ids: [id_at(0)], term: EmptyHole}; -// let empty_hole_menhir = () => -// alco_check_menhir( -// "Empty hole (str elaborated using the menhir parser)", -// empty_hole_str, -// empty_hole_uexp, -// ); -// -// //Test for a free variable -// let free_var_uexp: Term.UExp.t = { -// ids: [id_at(0)], -// term: Parens({ids: [id_at(1)], term: Var("y")}), -// }; -// let free_var_menhir = () => -// alco_check( -// "Nonempty hole with free variable (menhir)", -// Some( -// Haz3lcore.DHExp.of_menhir_ast( -// Haz3lmenhir.Interface.parse_program("{{?y}}"), -// get_id_menhir_closure(1), -// ), -// ), -// dhexp_of_uexp(free_var_uexp), -// ); -// -// //Menhir test for a binary operation -// let bin_op_uexp: Term.UExp.t = { -// ids: [id_at(0)], -// term: -// BinOp( -// Int(Plus), -// {ids: [id_at(1)], term: Bool(false)}, -// {ids: [id_at(2)], term: Var("y")}, -// ), -// }; -// let bin_op_menhir = () => -// alco_check( -// "Inconsistent binary integer operation (plus)", -// Some( -// Haz3lcore.DHExp.of_menhir_ast( -// Haz3lmenhir.Interface.parse_program("{{false}} + {{? y}}"), -// get_id_menhir_closure(1), -// ), -// ), -// dhexp_of_uexp(bin_op_uexp), -// ); -// -// //Inconsistent branches menhir test -// let inconsistent_case_menhir_str = " -// {{?case 4 == 3 -// | true => 24 -// | false => false -// end}} -// "; -// let inconsistent_case_uexp: Term.UExp.t = { -// ids: [id_at(0)], -// term: -// Match( -// { -// ids: [id_at(1)], -// term: -// BinOp( -// Int(Equals), -// {ids: [id_at(2)], term: Int(4)}, -// {ids: [id_at(3)], term: Int(3)}, -// ), -// }, -// [ -// ( -// {ids: [id_at(6)], term: Bool(true)}, -// {ids: [id_at(4)], term: Int(24)}, -// ), -// ( -// {ids: [id_at(7)], term: Bool(false)}, -// {ids: [id_at(5)], term: Bool(false)}, -// ), -// ], -// ), -// }; -// let inconsistent_case_menhir = () => -// alco_check_menhir( -// "Inconsistent branches where the first branch is an integer and second branch is a boolean (menhir)", -// inconsistent_case_menhir_str, -// inconsistent_case_uexp, -// ); -// -// //Function free var application menhir test -// let ap_fun_uexp: Term.UExp.t = { -// ids: [id_at(0)], -// term: -// Ap( -// { -// ids: [id_at(1)], -// term: -// Fun( -// {ids: [id_at(2)], term: Var("x")}, -// { -// ids: [id_at(3)], -// term: -// BinOp( -// Int(Plus), -// {ids: [id_at(4)], term: Int(4)}, -// {ids: [id_at(5)], term: Var("x")}, -// ), -// }, -// ), -// }, -// {ids: [id_at(6)], term: Var("y")}, -// ), -// }; -// let ap_fun_str = " -// (fun: Unknown Internal x -> 4 + x Int>)({{? y}}) -// "; -// let ap_fun_menhir = () => -// alco_check( -// "Application of a function of a free variable wrapped inside a nonempty hole constructor (menhir)", -// Some( -// Haz3lcore.DHExp.of_menhir_ast( -// Haz3lmenhir.Interface.parse_program(ap_fun_str), -// get_id_menhir_closure(6), -// ), -// ), -// dhexp_of_uexp(ap_fun_uexp), -// ); -// -// //Consistent if statement menhir test -// let consistent_if_uexp: Term.UExp.t = { -// ids: [id_at(0)], -// term: -// If( -// {ids: [id_at(1)], term: Bool(false)}, -// {ids: [id_at(2)], term: Int(8)}, -// {ids: [id_at(3)], term: Int(6)}, -// ), -// }; -// let consistent_if_str = " -// if false then 8 else 6 -// "; -// let consistent_if_menhir = () => -// alco_check( -// "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", -// Some( -// Haz3lcore.DHExp.of_menhir_ast( -// Haz3lmenhir.Interface.parse_program(consistent_if_str), -// get_id_menhir_closure(6), -// ), -// ), -// dhexp_of_uexp(consistent_if_uexp), -// ); -// -// //Single integer menhir test -// let single_int_str = "8"; -// let single_int_uexp: Term.UExp.t = {ids: [id_at(0)], term: Int(8)}; -// let single_integer_menhir = () => -// alco_check_menhir( -// "Single integer test (menhir)", -// single_int_str, -// single_int_uexp, -// ); -// -// //Menhir let expression test -// let let_exp_str = "let (a, b) = (4, 6) in a - b"; -// let let_exp_uexp: Term.UExp.t = { -// ids: [id_at(0)], -// term: -// Let( -// { -// ids: [id_at(1)], -// term: -// Tuple([ -// {ids: [id_at(2)], term: Var("a")}, -// {ids: [id_at(3)], term: Var("b")}, -// ]), -// }, -// { -// ids: [id_at(4)], -// term: -// Tuple([ -// {ids: [id_at(5)], term: Int(4)}, -// {ids: [id_at(6)], term: Int(6)}, -// ]), -// }, -// { -// ids: [id_at(7)], -// term: -// BinOp( -// Int(Minus), -// {ids: [id_at(8)], term: Var("a")}, -// {ids: [id_at(9)], term: Var("b")}, -// ), -// }, -// ), -// }; -// let let_exp_menhir = () => -// alco_check_menhir( -// "Let expression for tuple (a, b) (menhir)", -// let_exp_str, -// let_exp_uexp, -// ); -// -// let elaboration_tests = [ -// test_case("Let expression (menhir)", `Quick, let_exp_menhir), -// test_case("Single integer (menhir)", `Quick, single_integer_menhir), -// test_case("Let expression for a function (menhir)", `Quick, let_fun_menhir), -// test_case("Empty hole (menhir)", `Quick, empty_hole_menhir), -// test_case("Free var (menhir)", `Quick, free_var_menhir), -// test_case("Bin op (menhir)", `Quick, bin_op_menhir), -// test_case("Inconsistent case (menhir)", `Quick, inconsistent_case_menhir), -// test_case("ap fun (menhir)", `Quick, ap_fun_menhir), -// test_case("Consistent if (menhir)", `Quick, consistent_if_menhir), -// ]; -let u1: Exp.t = {ids: [id_at(0)], term: Int(8), copied: false}; -let single_integer = () => - alco_check("Integer literal 8", u1, dhexp_of_uexp(u1)); - -let u2: Exp.t = {ids: [id_at(0)], term: EmptyHole, copied: false}; -let empty_hole = () => alco_check("Empty hole", u2, dhexp_of_uexp(u2)); - -let u3: Exp.t = { - ids: [id_at(0)], - term: Parens({ids: [id_at(1)], term: Var("y"), copied: false}), - copied: false, -}; - -let free_var = () => alco_check("free variable", u3, dhexp_of_uexp(u3)); +let alco_check_menhir = (name: string, dhexp: string, uexp: Term.Exp.t) => + alco_check( + name, + Haz3lcore.TermBase.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(dhexp), + ), + dhexp_of_uexp(uexp), + ); -let u4: Exp.t = +//Test for a let function +let let_fun_uexp: Exp.t = Let( - Tuple([Var("a") |> Pat.fresh, Var("b") |> Pat.fresh]) |> Pat.fresh, - Tuple([Int(4) |> Exp.fresh, Int(6) |> Exp.fresh]) |> Exp.fresh, - BinOp(Int(Minus), Var("a") |> Exp.fresh, Var("b") |> Exp.fresh) - |> Exp.fresh, - ) - |> Exp.fresh; - -let let_exp = () => - alco_check("Let expression for tuple (a, b)", u4, dhexp_of_uexp(u4)); - -let u5 = - BinOp(Int(Plus), Bool(false) |> Exp.fresh, Var("y") |> Exp.fresh) - |> Exp.fresh; - -let d5 = - BinOp( - Int(Plus), - FailedCast(Bool(false) |> Exp.fresh, Bool |> Typ.fresh, Int |> Typ.fresh) - |> Exp.fresh, Cast( - Var("y") |> Exp.fresh, + Var("f") |> Pat.fresh, + Arrow(Int |> Typ.fresh, Int |> Typ.fresh) |> Typ.fresh, Unknown(Internal) |> Typ.fresh, - Int |> Typ.fresh, + ) + |> Pat.fresh, + Fun( + Var("x") |> Pat.fresh, + BinOp(Int(Plus), Int(1) |> Exp.fresh, Var("x") |> Exp.fresh) + |> Exp.fresh, + None, + None, ) |> Exp.fresh, + Int(55) |> Exp.fresh, ) |> Exp.fresh; -let bin_op = () => - alco_check( - "Inconsistent binary integer operation (plus)", - d5, - dhexp_of_uexp(u5), +let let_fun_str = " +let f = + fun x -> + 1 + x + f + in +55"; +let let_fun_menhir = () => + alco_check_menhir( + "Let expression for a function which is not recursive (menhir)", + let_fun_str, + let_fun_uexp, ); -let u6: Exp.t = - If(Bool(false) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) - |> Exp.fresh; +//Test for an empty hole +let empty_hole_str = "?"; +let empty_hole_uexp: Exp.t = { + ids: [id_at(0)], + term: EmptyHole, + copied: false, +}; +let empty_hole_menhir = () => + alco_check_menhir("Empty hole (menhir)", empty_hole_str, empty_hole_uexp); -let consistent_if = () => +//Test for a free variable +let free_var_uexp: Exp.t = { + ids: [id_at(0)], + term: Parens({ids: [id_at(1)], term: Var("y"), copied: false}), + copied: false, +}; +let free_var_menhir = () => alco_check( - "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", - u6, - dhexp_of_uexp(u6), + "Nonempty hole with free variable (menhir)", + Haz3lcore.TermBase.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program("y"), + ), + dhexp_of_uexp(free_var_uexp), ); -let u7: Exp.t = - Ap( - Forward, - Fun( - Var("x") |> Pat.fresh, - BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) - |> Exp.fresh, - None, - None, - ) - |> Exp.fresh, - Var("y") |> Exp.fresh, - ) +//Menhir test for a binary operation +let bin_op_uexp: Exp.t = + BinOp(Int(Plus), Bool(false) |> Exp.fresh, Var("y") |> Exp.fresh) |> Exp.fresh; -let ap_fun = () => - alco_check("Application of a function", u7, dhexp_of_uexp(u7)); +let bin_op_str = "false? Int> + y Int>"; -let u8: Exp.t = +let bin_op_menhir = () => + alco_check( + "Inconsistent binary integer operation (plus)", + Haz3lcore.DHExp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(bin_op_str), + ), + dhexp_of_uexp(bin_op_uexp), + ); + +//Inconsistent branches menhir test +let inconsistent_case_menhir_str = " + case 4 == 3 + | true => 24 Unknown Internal> + | false => false Unknown Internal> + end +"; +let inconsistent_case_uexp: Exp.t = Match( BinOp(Int(Equals), Int(4) |> Exp.fresh, Int(3) |> Exp.fresh) |> Exp.fresh, @@ -398,91 +131,97 @@ let u8: Exp.t = ], ) |> Exp.fresh; - -let d8: Exp.t = - Match( - BinOp(Int(Equals), Int(4) |> Exp.fresh, Int(3) |> Exp.fresh) - |> Exp.fresh, - [ - ( - Bool(true) |> Pat.fresh, - Cast( - Int(24) |> Exp.fresh, - Int |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) - |> Exp.fresh, - ), - ( - Bool(false) |> Pat.fresh, - Cast( - Bool(false) |> Exp.fresh, - Bool |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) - |> Exp.fresh, - ), - ], - ) - |> Exp.fresh; - -let inconsistent_case = () => - alco_check( - "Inconsistent branches where the first branch is an integer and second branch is a boolean", - d8, - dhexp_of_uexp(u8), +let inconsistent_case_menhir = () => + alco_check_menhir( + "Inconsistent branches where the first branch is an integer and second branch is a boolean (menhir)", + inconsistent_case_menhir_str, + inconsistent_case_uexp, ); -let u9: Exp.t = - Let( - Cast( - Var("f") |> Pat.fresh, - Arrow(Int |> Typ.fresh, Int |> Typ.fresh) |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) - |> Pat.fresh, +//Function free var application menhir test +let ap_fun_uexp: Exp.t = + Ap( + Forward, Fun( Var("x") |> Pat.fresh, - BinOp(Int(Plus), Int(1) |> Exp.fresh, Var("x") |> Exp.fresh) + BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) |> Exp.fresh, None, None, ) |> Exp.fresh, - Int(55) |> Exp.fresh, + Var("y") |> Exp.fresh, ) |> Exp.fresh; -let d9: Exp.t = +let ap_fun_str = " + (fun x -> 4 + 5)(y) +"; +let ap_fun_menhir = () => + alco_check( + "Application of a function (menhir)", + Haz3lcore.DHExp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(ap_fun_str), + ), + dhexp_of_uexp(ap_fun_uexp), + ); + +//Consistent if statement menhir test +let consistent_if_uexp: Exp.t = + If(Bool(false) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) + |> Exp.fresh; + +let consistent_if_str = " + if false then 8 else 6 +"; +let consistent_if_menhir = () => + alco_check( + "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", + Haz3lcore.DHExp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(consistent_if_str), + ), + dhexp_of_uexp(consistent_if_uexp), + ); + +//Single integer menhir test +let single_int_str = "8"; +let single_int_uexp: Exp.t = { + ids: [id_at(0)], + term: Int(8), + copied: false, +}; +let single_integer_menhir = () => + alco_check_menhir( + "Single integer test (menhir)", + single_int_str, + single_int_uexp, + ); + +//Menhir let expression test +let let_exp_str = "let (a, b) = (4, 6) in a - b"; +let let_exp_uexp: Exp.t = Let( - Var("f") |> Pat.fresh, - Fun( - Var("x") |> Pat.fresh, - BinOp(Int(Plus), Int(1) |> Exp.fresh, Var("x") |> Exp.fresh) - |> Exp.fresh, - None, - Some("f"), - ) + Tuple([Var("a") |> Pat.fresh, Var("b") |> Pat.fresh]) |> Pat.fresh, + Tuple([Int(4) |> Exp.fresh, Int(6) |> Exp.fresh]) |> Exp.fresh, + BinOp(Int(Minus), Var("a") |> Exp.fresh, Var("b") |> Exp.fresh) |> Exp.fresh, - Int(55) |> Exp.fresh, ) |> Exp.fresh; - -let let_fun = () => - alco_check( - "Let expression for function which is not recursive", - d9, - dhexp_of_uexp(u9), +let let_exp_menhir = () => + alco_check_menhir( + "Let expression for tuple (a, b) (menhir)", + let_exp_str, + let_exp_uexp, ); let elaboration_tests = [ - test_case("Single integer", `Quick, single_integer), - test_case("Empty hole", `Quick, empty_hole), - test_case("Free variable", `Quick, free_var), - test_case("Let expression", `Quick, let_exp), - test_case("Inconsistent binary operation", `Quick, bin_op), - test_case("Consistent if statement", `Quick, consistent_if), - test_case("Application of function on free variable", `Quick, ap_fun), - test_case("Inconsistent case statement", `Quick, inconsistent_case), - test_case("Let expression for a function", `Quick, let_fun), + test_case("Let expression for a tuple (menhir)", `Quick, let_exp_menhir), + test_case("Single integer (menhir)", `Quick, single_integer_menhir), + test_case("Let expression for a function (menhir)", `Quick, let_fun_menhir), + test_case("Empty hole (menhir)", `Quick, empty_hole_menhir), + test_case("Free var (menhir)", `Quick, free_var_menhir), + test_case("Bin op (menhir)", `Quick, bin_op_menhir), + test_case("Inconsistent case (menhir)", `Quick, inconsistent_case_menhir), + test_case("ap fun (menhir)", `Quick, ap_fun_menhir), + test_case("Consistent if (menhir)", `Quick, consistent_if_menhir), ]; diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index dc9e3d7bb2..ad7e32f510 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -72,25 +72,25 @@ let parser_test = (a, expected, actual, ()) => // ), // ); -let fun_exp = AST.Fun(IntType, VarPat("x"), Var("x"), None); - -let fun_str = "fun: Int x -> x"; - -let tests = [ - test_case( - "Integer Literal", - `Quick, - parser_test("Same Integer", Int(8), "8"), - ), - test_case("Fun", `Quick, parser_test("Fun", fun_exp, fun_str)), - // test_case( - // "String Literal", - // `Quick, - // parser_test("Same String", String("Hello World"), "\"Hello World\""), - // ), - // test_case( - // "Bigger expression", - // `Quick, - // parser_test("test.hazel contents", bigger_expression, file_contents), - // ), -]; +// let fun_exp = AST.Fun(IntType, VarPat("x"), Var("x"), None); +// +// let fun_str = "fun: Int x -> x"; +// +// let tests = [ +// test_case( +// "Integer Literal", +// `Quick, +// parser_test("Same Integer", Int(8), "8"), +// ), +// test_case("Fun", `Quick, parser_test("Fun", fun_exp, fun_str)), +// test_case( +// "String Literal", +// `Quick, +// parser_test("Same String", String("Hello World"), "\"Hello World\""), +// ), +// test_case( +// "Bigger expression", +// `Quick, +// parser_test("test.hazel contents", bigger_expression, file_contents), +// ), +// ]; diff --git a/test/haz3ltest.re b/test/haz3ltest.re index 04b8b36b76..43e92fa01c 100644 --- a/test/haz3ltest.re +++ b/test/haz3ltest.re @@ -5,8 +5,8 @@ let (suite, _) = ~and_exit=false, "Dynamics", [ - // ("Elaboration", Test_Elaboration.elaboration_tests), - ("Parser", Test_Menhir.tests), + ("Elaboration", Test_Elaboration.elaboration_tests), + // ("Parser", Test_Menhir.tests), ], ); Junit.to_file(Junit.make([suite]), "junit_tests.xml"); From 834a803f277f6599cedfea9c635b9bf093e8de9b Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 28 Jun 2024 15:46:35 -0400 Subject: [PATCH 035/281] Added documentation for exp menhir textual syntax --- src/haz3lcore/statics/TermBase.re | 71 +++++++++++++++++-------------- 1 file changed, 39 insertions(+), 32 deletions(-) diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index 79d63c4f3a..0bee050991 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -131,52 +131,59 @@ and Exp: { | InAp | OutsideAp; + //Comments represent the textual syntax of each term for use in the menhir parser + //e = exp, ty = typ, tp = tpat, p = pat, s = string, x = ident [@deriving (show({with_path: false}), sexp, yojson)] type term = - //TODO: closure environments in menhir - | Invalid(string) - | EmptyHole - | MultiHole(list(Any.t)) + | Invalid(string) //? s + | EmptyHole //? + | MultiHole(list(Any.t)) //<> | DynamicErrorHole(t, InvalidOperationError.t) //TODO menhir - | FailedCast(t, Typ.t, Typ.t) - | Deferral(deferral_position) - | Bool(bool) - | Int(int) - | Float(float) - | String(string) - | ListLit(list(t)) - | Constructor(string) + | FailedCast(t, Typ.t, Typ.t) //e ? ty2> + | Deferral(deferral_position) /*InAp _*/ /*OutAp _*/ + | Bool(bool) //false + | Int(int) //1 + | Float(float) //1.0 + | String(string) //"hi" + | ListLit(list(t)) //[e1, e2, ...] + | Constructor(string) /*capitalized ident*/ //X | Fun( Pat.t, t, [@show.opaque] option(ClosureEnvironment.t), option(Var.t), - ) - | TypFun(TPat.t, t, option(Var.t)) - | Tuple(list(t)) - | Var(Var.t) - | Let(Pat.t, t, t) - | FixF(Pat.t, t, option(ClosureEnvironment.t)) - | TyAlias(TPat.t, Typ.t, t) - | Ap(Operators.ap_direction, t, t) - | TypAp(t, Typ.t) + ) //fun p -> e1 opt(x) + | TypFun(TPat.t, t, option(Var.t)) //typfun tp -> e + | Tuple(list(t)) //(e1, e2) + | Var(Var.t) //x + | Let(Pat.t, t, t) //let p = e1 in e2 + | FixF(Pat.t, t, option(ClosureEnvironment.t)) //fix p -> e + | TyAlias(TPat.t, Typ.t, t) //type tp = ty in e + | Ap(Operators.ap_direction, t, t) //e1(e2) + | TypAp(t, Typ.t) /*e @ {ty} */ /*NOTE: syntax is ugly bc of menhir parser conflicts*/ | DeferredAp(t, list(t)) //TODO menhir - | If(t, t, t) - | Seq(t, t) - | Test(t) - | Filter(StepperFilterKind.t, t) - | Closure([@show.opaque] ClosureEnvironment.t, t) - | Parens(t) // ( - | Cons(t, t) - | ListConcat(t, t) - | UnOp(Operators.op_un, t) - | BinOp(Operators.op_bin, t, t) + | If(t, t, t) //if e1 then e2 else e3 + | Seq(t, t) //e1;e2 + | Test(t) //test e end + | Filter(StepperFilterKind.t, t) /*let act represent filter action*/ //act e1 e2 + | Closure([@show.opaque] ClosureEnvironment.t, t) //TODO menhir + | Parens(t) //TODO menhir + | Cons(t, t) //e1 :: e2 + | ListConcat(t, t) //e1 @ e2 + | UnOp(Operators.op_un, t) //!e -e $e + | BinOp(Operators.op_bin, t, t) //e1 + e2 | BuiltinFun(string) //TODO menhir | Match(t, list((Pat.t, t))) + /* + case e1 + | p1 => e2 + | p2 => e3 + end + */ /* INVARIANT: in dynamic expressions, casts must be between two consistent types. Both types should be normalized in dynamics for the cast calculus to work right. */ - | Cast(t, Typ.t, Typ.t) + | Cast(t, Typ.t, Typ.t) //e1 ty2> and t = IdTagged.t(term); let map_term: From 8af6998f334f493bb6deae3360f6315710a3640c Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Thu, 25 Jul 2024 16:32:49 -0400 Subject: [PATCH 036/281] Updated some of the textual exp syntax with the menhir parser --- src/haz3lcore/statics/TermBase.re | 20 +++++++++++++------- src/haz3lmenhir/AST.re | 1 + src/haz3lmenhir/Lexer.mll | 3 +++ src/haz3lmenhir/Parser.mly | 7 +++++-- 4 files changed, 22 insertions(+), 9 deletions(-) diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index 0bee050991..19fbce4465 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -137,8 +137,8 @@ and Exp: { type term = | Invalid(string) //? s | EmptyHole //? - | MultiHole(list(Any.t)) //<> - | DynamicErrorHole(t, InvalidOperationError.t) //TODO menhir + | MultiHole(list(Any.t)) //<> TODO: not necessary for parser - cyrus + | DynamicErrorHole(t, InvalidOperationError.t) //TODO menhir - for the error message take the s exp serialization of the type and pass it in to the s expression parser | FailedCast(t, Typ.t, Typ.t) //e ? ty2> | Deferral(deferral_position) /*InAp _*/ /*OutAp _*/ | Bool(bool) //false @@ -160,14 +160,14 @@ and Exp: { | FixF(Pat.t, t, option(ClosureEnvironment.t)) //fix p -> e | TyAlias(TPat.t, Typ.t, t) //type tp = ty in e | Ap(Operators.ap_direction, t, t) //e1(e2) - | TypAp(t, Typ.t) /*e @ {ty} */ /*NOTE: syntax is ugly bc of menhir parser conflicts*/ - | DeferredAp(t, list(t)) //TODO menhir + | TypAp(t, Typ.t) /*e @ */ + | DeferredAp(t, list(t)) //_e1(e2) | If(t, t, t) //if e1 then e2 else e3 | Seq(t, t) //e1;e2 | Test(t) //test e end | Filter(StepperFilterKind.t, t) /*let act represent filter action*/ //act e1 e2 - | Closure([@show.opaque] ClosureEnvironment.t, t) //TODO menhir - | Parens(t) //TODO menhir + | Closure([@show.opaque] ClosureEnvironment.t, t) // menhir - spoke with cyrus we don't need closures in the menhir + | Parens(t) // (e) | Cons(t, t) //e1 :: e2 | ListConcat(t, t) //e1 @ e2 | UnOp(Operators.op_un, t) //!e -e $e @@ -267,7 +267,12 @@ and Exp: { | OutsideAp => Deferral(OutsideAp) } | ListExp(l) => ListLit(List.map(of_menhir_ast, l)) - | TupleExp(t) => Tuple(List.map(of_menhir_ast, t)) + | TupleExp(t) => + if (List.length(t) == 1) { + Parens(of_menhir_ast(List.hd(t))); + } else { + Tuple(List.map(of_menhir_ast, t)); + } | Let(p, e1, e2) => Let(Pat.of_menhir_ast(p), of_menhir_ast(e1), of_menhir_ast(e2)) | FixF(p, e) => FixF(Pat.of_menhir_ast(p), of_menhir_ast(e), None) @@ -278,6 +283,7 @@ and Exp: { Typ.of_menhir_ast(ty), of_menhir_ast(e), ) + | DeferredAp(f, a) => DeferredAp(of_menhir_ast(f), [of_menhir_ast(a)]) | Fun(p, e, name_opt) => switch (name_opt) { | Some(name_str) => diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 5f99cc0f18..246c3e082d 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -146,4 +146,5 @@ type exp = | If(exp, exp, exp) | InvalidExp(string) | TypAp(exp, typ) + | DeferredAp(exp, exp) | TyAlias(tpat, typ, exp); diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index d42d69fb4d..b9290e3881 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -24,6 +24,8 @@ let whitespace = [' ' '\t']+ let identifier = ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* let constructor_ident = ['A'-'Z'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* +let builtins = ["infinity", "neg_infinity", "nan", "epsilon_float", "pi", "max_int", "min_int", "is_finite", "is_infinite", "int_of_float", "float_of_int", "string_of_int", "string_of_float", "string_of_bool", "int_of_string", "float_of_string", "bool_of_string", "abs", "abs_float", "ceil", "floor", "exp", "log", "log10", "sqrt", "sin", "cos", "tan", "asin", "acos", "atan", "mod", "string_length", "string_compare", "string_trim", "string_concat", "string_sub"] + rule token = parse | whitespace {token lexbuf } @@ -111,6 +113,7 @@ rule token = | "typfun" {TYP_FUN} | "type" {TYP} | "$" {DOLLAR_SIGN} + | builtins as b {BUILIN(b)} | identifier as i { IDENT(i) } | constructor_ident as i { CONSTRUCTOR_IDENT(i)} | eof { EOF } diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 566ce09c3d..3ebbdb1c46 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -22,6 +22,7 @@ open AST %token IDENT %token CONSTRUCTOR_IDENT %token STRING +%token BUILTIN %token TRUE %token FALSE %token INT @@ -221,10 +222,11 @@ exp: | s = STRING { String s} | b = binExp { b } | OPEN_PAREN; e = exp; CLOSE_PAREN { e } - | OPEN_PAREN; l = separated_list(COMMA, exp); CLOSE_PAREN { TupleExp(l)} + | OPEN_PAREN; l = separated_list(COMMA, exp); CLOSE_PAREN { TupleExp(l) } | c = case { c } | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ListExp(e) } | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } + | WILD; f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { DeferredAp(f, a) } | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } | i = ifExp { i} | e1 = exp; QUESTION; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN {FailedCast(e1, t1, t2)} @@ -244,6 +246,7 @@ exp: | QUESTION; s = STRING; { InvalidExp(s) } | IN_AP; WILD {Deferral(InAp)} | OUT_AP; WILD {Deferral(OutsideAp)} - | e = exp; AT_SYMBOL; OPEN_BRACKET; ty = typ; CLOSE_BRACKET; {TypAp(e, ty)} + | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} + | b = BUILTIN; OPEN_PAREN; a = exp; CLOSE_PAREN {BuiltinAp(b, a)} | u = unExp { u } From a783dd52d68a485c7ff66e9c7344476f30d1cb57 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sun, 4 Aug 2024 21:47:54 -0400 Subject: [PATCH 037/281] Fixed conflicts from recent update to dev --- src/haz3lcore/statics/TermBase.re | 15 +++++++------ src/haz3lmenhir/AST.re | 36 +++++++++++++++---------------- src/haz3lmenhir/Lexer.mll | 4 ++-- src/haz3lmenhir/Parser.mly | 6 +++--- 4 files changed, 31 insertions(+), 30 deletions(-) diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index 38c7e02a3f..b7b7693d7e 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -147,7 +147,7 @@ and Exp: { | Float(float) //1.0 | String(string) //"hi" | ListLit(list(t)) //[e1, e2, ...] - | Constructor(string) /*capitalized ident*/ //X + | Constructor(string, Typ.t) /*capitalized ident*/ //X: ty | Fun( Pat.t, t, @@ -201,8 +201,8 @@ and Exp: { let fast_equal: (t, t) => bool; - let term_of_menhir_ast: Haz3lmenhir.AST.exp => term; - let of_menhir_ast: Haz3lmenhir.AST.exp => t; + let term_of_menhir_ast: Haz3lmenhir.AST.exp => Exp.term; + let of_menhir_ast: Haz3lmenhir.AST.exp => Exp.t; } = { [@deriving (show({with_path: false}), sexp, yojson)] type deferral_position = @@ -254,7 +254,7 @@ and Exp: { | Cast(t, Typ.t, Typ.t) and t = IdTagged.t(term); - let rec term_of_menhir_ast = (exp: Haz3lmenhir.AST.exp): term => { + let rec term_of_menhir_ast = (exp: Haz3lmenhir.AST.exp): Exp.term => { switch (exp) { | InvalidExp(s) => Invalid(s) | Int(i) => Int(i) @@ -262,7 +262,7 @@ and Exp: { | String(s) => String(s) | Bool(b) => Bool(b) | Var(x) => Var(x) - | Constructor(x) => Constructor(x) + | Constructor(x, ty) => Constructor(x, Typ.of_menhir_ast(ty)) | Deferral(pos) => switch (pos) { | InAp => Deferral(InAp) @@ -351,7 +351,7 @@ and Exp: { // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) }; } - and of_menhir_ast = (exp: Haz3lmenhir.AST.exp): t => { + and of_menhir_ast = (exp: Haz3lmenhir.AST.exp): Exp.t => { IdTagged.fresh(term_of_menhir_ast(exp)); }; @@ -622,7 +622,7 @@ and Pat: { | IntPat(i) => Int(i) | FloatPat(f) => Float(f) | VarPat(x) => Var(x) - | ConstructorPat(x) => Constructor(x) + | ConstructorPat(x, ty) => Constructor(x, Typ.of_menhir_ast(ty)) | StringPat(s) => String(s) | TuplePat(pats) => Tuple(List.map(of_menhir_ast, pats)) | ApPat(pat1, pat2) => Ap(of_menhir_ast(pat1), of_menhir_ast(pat2)) @@ -634,6 +634,7 @@ and Pat: { MultiHole([Pat(p)]); | WildPat => Wild | ListPat(l) => ListLit(List.map(of_menhir_ast, l)) + // | _ => raise(Invalid_argument("Menhir AST -> DHPat not yet implemented")) }; } and of_menhir_ast = (pat: Haz3lmenhir.AST.pat): t => { diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 246c3e082d..20b006a306 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -1,13 +1,13 @@ open Sexplib.Std; -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type filter_action = | Pause | Debug | Hide | Eval; -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type op_bin_float = | Plus | Minus @@ -21,12 +21,12 @@ type op_bin_float = | Equals | NotEquals; -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type op_bin_bool = | And | Or; -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type op_bin_int = | Plus | Minus @@ -40,35 +40,35 @@ type op_bin_int = | Equals | NotEquals; -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type binOp = | IntOp(op_bin_int) | FloatOp(op_bin_float) | BoolOp(op_bin_bool); -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type op_un_meta = | Unquote; -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type op_un_int = | Minus; -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type op_un_bool = | Not; -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type op_un = | Meta(op_un_meta) | Int(op_un_int) | Bool(op_un_bool); -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type typ_provenance = | Internal; -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type typ = | IntType | StringType @@ -81,7 +81,7 @@ type typ = | ArrowType(typ, typ) | InvalidTyp(string); -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type pat = | EmptyHolePat | WildPat @@ -89,7 +89,7 @@ type pat = | IntPat(int) | FloatPat(float) | VarPat(string) - | ConstructorPat(string) + | ConstructorPat(string, typ) | StringPat(string) | TuplePat(list(pat)) | BoolPat(bool) @@ -98,29 +98,29 @@ type pat = | ApPat(pat, pat) | InvalidPat(string); -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type if_consistency = | Consistent | Inconsistent; -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type deferral_pos = | InAp | OutsideAp; -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type tpat = | InvalidTPat(string) | EmptyHoleTPat | MultiHoleTPat(tpat) | VarTPat(string); -[@deriving (show({with_path: false}), sexp, yojson)] +[@deriving (show({with_path: false}), sexp)] type exp = | Int(int) | Float(float) | Var(string) - | Constructor(string) + | Constructor(string, typ) | String(string) | ListExp(list(exp)) | TupleExp(list(exp)) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index b9290e3881..ddd45120f0 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -24,7 +24,7 @@ let whitespace = [' ' '\t']+ let identifier = ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* let constructor_ident = ['A'-'Z'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* -let builtins = ["infinity", "neg_infinity", "nan", "epsilon_float", "pi", "max_int", "min_int", "is_finite", "is_infinite", "int_of_float", "float_of_int", "string_of_int", "string_of_float", "string_of_bool", "int_of_string", "float_of_string", "bool_of_string", "abs", "abs_float", "ceil", "floor", "exp", "log", "log10", "sqrt", "sin", "cos", "tan", "asin", "acos", "atan", "mod", "string_length", "string_compare", "string_trim", "string_concat", "string_sub"] +(* let builtins = ["infinity", "neg_infinity", "nan", "epsilon_float", "pi", "max_int", "min_int", "is_finite", "is_infinite", "int_of_float", "float_of_int", "string_of_int", "string_of_float", "string_of_bool", "int_of_string", "float_of_string", "bool_of_string", "abs", "abs_float", "ceil", "floor", "exp", "log", "log10", "sqrt", "sin", "cos", "tan", "asin", "acos", "atan", "mod", "string_length", "string_compare", "string_trim", "string_concat", "string_sub"] *) rule token = parse @@ -113,7 +113,7 @@ rule token = | "typfun" {TYP_FUN} | "type" {TYP} | "$" {DOLLAR_SIGN} - | builtins as b {BUILIN(b)} + (* | builtins as b {BUILIN(b)} *) | identifier as i { IDENT(i) } | constructor_ident as i { CONSTRUCTOR_IDENT(i)} | eof { EOF } diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 3ebbdb1c46..2ca3c912ea 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -163,7 +163,7 @@ pat: | WILD { WildPat } | QUESTION { EmptyHolePat } | OPEN_SQUARE_BRACKET; l = separated_list(COMMA, pat); CLOSE_SQUARE_BRACKET; { ListPat(l) } - | c = CONSTRUCTOR_IDENT { ConstructorPat(c) } + | c = CONSTRUCTOR_IDENT; COLON; t = typ; { ConstructorPat(c, t) } | p = varPat {p} | t = patTuple { t } (* | t = typeAnn { t } *) @@ -218,7 +218,7 @@ exp: | i = INT { Int i } | f = FLOAT { Float f } | v = IDENT { Var v } - | c = CONSTRUCTOR_IDENT { Constructor c } + | c = CONSTRUCTOR_IDENT; COLON; t = typ { Constructor(c, t) } | s = STRING { String s} | b = binExp { b } | OPEN_PAREN; e = exp; CLOSE_PAREN { e } @@ -248,5 +248,5 @@ exp: | OUT_AP; WILD {Deferral(OutsideAp)} | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} - | b = BUILTIN; OPEN_PAREN; a = exp; CLOSE_PAREN {BuiltinAp(b, a)} + (* | b = BUILTIN; OPEN_PAREN; a = exp; CLOSE_PAREN {BuiltinAp(b, a)} *) | u = unExp { u } From d27ff090e44263ed973e92a757cce33dc1840eca Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Tue, 6 Aug 2024 21:43:48 -0400 Subject: [PATCH 038/281] Added more elaboration tests & added in DynamicErrorHole menhir parsing --- Makefile | 4 +-- src/haz3lcore/statics/TermBase.re | 9 +++-- src/haz3lmenhir/AST.re | 1 + src/haz3lmenhir/Parser.mly | 3 +- test/Test_Elaboration.re | 57 +++++++++++++++++++++++++++++++ 5 files changed, 69 insertions(+), 5 deletions(-) diff --git a/Makefile b/Makefile index 080c9e0365..329989f8e4 100644 --- a/Makefile +++ b/Makefile @@ -55,8 +55,8 @@ repl: dune utop src/haz3lcore test: - dune build @src/fmt @test/fmt --auto-promote src test --profile dev - node $(TEST_DIR)/haz3ltest.bc.js + dune fmt --auto-promote + dune build @src/fmt @test/fmt --auto-promote src test --profile dev; node $(TEST_DIR)/haz3ltest.bc.js clean: dune clean diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index b7b7693d7e..eca3bdb4f2 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -137,8 +137,8 @@ and Exp: { type term = | Invalid(string) //? s | EmptyHole //? - | MultiHole(list(Any.t)) //<> TODO: not necessary for parser - cyrus - | DynamicErrorHole(t, InvalidOperationError.t) //TODO menhir - for the error message take the s exp serialization of the type and pass it in to the s expression parser + | MultiHole(list(Any.t)) //<> //TODO: not necessary for parser - cyrus + | DynamicErrorHole(t, InvalidOperationError.t) //This exp takes in the Sexp serialization of the InvalidOperationError.t as a string (s); // <> | FailedCast(t, Typ.t, Typ.t) //e ? ty2> | Deferral(deferral_position) /*InAp _*/ /*OutAp _*/ | Undefined @@ -348,6 +348,11 @@ and Exp: { | TypAp(e, ty) => TypAp(of_menhir_ast(e), Typ.of_menhir_ast(ty)) | UnOp(op, e) => UnOp(Operators.op_un_of_menhir_ast(op), of_menhir_ast(e)) + | DynamicErrorHole(e, s) => + DynamicErrorHole( + of_menhir_ast(e), + InvalidOperationError.t_of_sexp(sexp_of_string(s)), + ) // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) }; } diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 20b006a306..6c67627b95 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -147,4 +147,5 @@ type exp = | InvalidExp(string) | TypAp(exp, typ) | DeferredAp(exp, exp) + | DynamicErrorHole(exp, string) | TyAlias(tpat, typ, exp); diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 2ca3c912ea..e41d6ee186 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -236,7 +236,7 @@ exp: | FALSE { Bool false } | FIX; p = pat; DASH_ARROW; e = exp { FixF(p, e) } | TYP_FUN; t = tpat; DASH_ARROW; e = exp {TypFun(t, e)} - | OPEN_BRACKET; OPEN_BRACKET; e = exp; CLOSE_BRACKET; CLOSE_BRACKET {MultiHole e} + | LESS_THAN; LESS_THAN; e = exp; GREATER_THAN; GREATER_THAN {MultiHole e} | QUESTION { EmptyHole } | a = filterAction; cond = exp; body = exp { Filter(a, cond, body)} | TEST; e = exp; END { Test(e) } @@ -248,5 +248,6 @@ exp: | OUT_AP; WILD {Deferral(OutsideAp)} | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} + | LESS_THAN; LESS_THAN; e = exp; QUESTION; s = STRING; GREATER_THAN; GREATER_THAN {DynamicErrorHole(e, s)} (* | b = BUILTIN; OPEN_PAREN; a = exp; CLOSE_PAREN {BuiltinAp(b, a)} *) | u = unExp { u } diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 6d9bcb0b69..81c45ffb94 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -214,7 +214,64 @@ let let_exp_menhir = () => let_exp_uexp, ); +let typ_ap_str = "(typfun x -> 4) @ "; +let typ_ap_uexp: Exp.t = + TypAp( + TypFun(Var("x") |> TPat.fresh, Int(4) |> Exp.fresh, None) |> Exp.fresh, + Int |> Typ.fresh, + ) + |> Exp.fresh; +let typ_ap_menhir = () => + alco_check_menhir("Type ap test (menhir)", typ_ap_str, typ_ap_uexp); + +let failed_cast_str = "1 ? String>"; +let failed_cast_uexp: Exp.t = + FailedCast(Int(1) |> Exp.fresh, Int |> Typ.fresh, String |> Typ.fresh) + |> Exp.fresh; +let failed_cast_menhir = () => + alco_check_menhir( + "Failed cast test (menhir)", + failed_cast_str, + failed_cast_uexp, + ); + +let constructor_str = "X: Unknown Internal"; +let constructor_uexp: Exp.t = + Constructor("X", Unknown(Internal) |> Typ.fresh) |> Exp.fresh; +let constructor_menhir = () => + alco_check_menhir( + "Constructor test (menhir)", + constructor_str, + constructor_uexp, + ); + + +//TODO: ask cyrus best way to demonstrate this +// let ty_alias_str = "type x = Int in 4"; +// let ty_alias_uexp: Exp.t = +// TyAlias( +// Var("x") |> TPat.fresh, +// Int |> Typ.fresh, +// TypAp( +// TypFun(Var("y") |> TPat.fresh, Var("y") |> Exp.fresh, None) +// |> Exp.fresh, +// Var("x") |> Typ.fresh, +// ) +// |> Exp.fresh, +// ) +// |> Exp.fresh; +// let ty_alias_menhir = () => +// alco_check_menhir("Type alias test (menhir)", ty_alias_str, ty_alias_uexp); + +let + + + let elaboration_tests = [ + // test_case("Type alias test (menhir)", `Quick, ty_alias_menhir), + test_case("Constructor test (menhir)", `Quick, constructor_menhir), + test_case("Failed cast test (menhir)", `Quick, failed_cast_menhir), + test_case("Type ap test (menhir)", `Quick, typ_ap_menhir), test_case("Let expression for a tuple (menhir)", `Quick, let_exp_menhir), test_case("Single integer (menhir)", `Quick, single_integer_menhir), test_case("Let expression for a function (menhir)", `Quick, let_fun_menhir), From e81fbdbfa5f0fc81025d97f197ba27dc8ca097ff Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 12 Aug 2024 14:01:04 -0400 Subject: [PATCH 039/281] Added in sexp serialization for InvalidOperationError test --- src/haz3lmenhir/Lexer.mll | 2 ++ src/haz3lmenhir/Parser.mly | 4 ++-- test/Test_Elaboration.re | 47 +++++++++++++++++++++----------------- 3 files changed, 30 insertions(+), 23 deletions(-) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index ddd45120f0..8a63d2519c 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -23,6 +23,7 @@ let whitespace = [' ' '\t']+ let identifier = ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* let constructor_ident = ['A'-'Z'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* +let sexp_string = '`' [^'`']* '`' (* let builtins = ["infinity", "neg_infinity", "nan", "epsilon_float", "pi", "max_int", "min_int", "is_finite", "is_infinite", "int_of_float", "float_of_int", "string_of_int", "string_of_float", "string_of_bool", "int_of_string", "float_of_string", "bool_of_string", "abs", "abs_float", "ceil", "floor", "exp", "log", "log10", "sqrt", "sin", "cos", "tan", "asin", "acos", "atan", "mod", "string_length", "string_compare", "string_trim", "string_concat", "string_sub"] *) @@ -33,6 +34,7 @@ rule token = | int as i { INT (int_of_string i) } | float as f { FLOAT (float_of_string f )} | string as s { STRING (String.sub s 1 (String.length s - 2)) } + | sexp_string as s { SEXP_STRING (String.sub s 1 (String.length s - 2)) } | "true" { TRUE } | "false" { FALSE } | "let" { LET } diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index e41d6ee186..48eefad46c 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -2,7 +2,7 @@ open AST %} - +%token SEXP_STRING %token DOLLAR_SIGN %token TYP %token TYP_FUN @@ -248,6 +248,6 @@ exp: | OUT_AP; WILD {Deferral(OutsideAp)} | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} - | LESS_THAN; LESS_THAN; e = exp; QUESTION; s = STRING; GREATER_THAN; GREATER_THAN {DynamicErrorHole(e, s)} + | LESS_THAN; LESS_THAN; e = exp; QUESTION; s = SEXP_STRING; GREATER_THAN; GREATER_THAN {DynamicErrorHole(e, s)} (* | b = BUILTIN; OPEN_PAREN; a = exp; CLOSE_PAREN {BuiltinAp(b, a)} *) | u = unExp { u } diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 81c45ffb94..6b8dd74521 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -245,30 +245,35 @@ let constructor_menhir = () => constructor_uexp, ); +/* + <<1 / 2 ? `a`>> + */ +print_endline("SEXP seiralization:"); +InvalidOperationError.DivideByZero +|> InvalidOperationError.sexp_of_t +|> Sexplib.Sexp.to_string +|> print_endline; -//TODO: ask cyrus best way to demonstrate this -// let ty_alias_str = "type x = Int in 4"; -// let ty_alias_uexp: Exp.t = -// TyAlias( -// Var("x") |> TPat.fresh, -// Int |> Typ.fresh, -// TypAp( -// TypFun(Var("y") |> TPat.fresh, Var("y") |> Exp.fresh, None) -// |> Exp.fresh, -// Var("x") |> Typ.fresh, -// ) -// |> Exp.fresh, -// ) -// |> Exp.fresh; -// let ty_alias_menhir = () => -// alco_check_menhir("Type alias test (menhir)", ty_alias_str, ty_alias_uexp); - -let - - +let dynamic_error_hole_str = "<<(1/0) ? `DivideByZero`>> Int>"; +let dynamic_error_hole_uexp: Exp.t = { + ids: [id_at(0)], + term: + DynamicErrorHole( + BinOp(Int(Divide), Int(1) |> Exp.fresh, Int(0) |> Exp.fresh) + |> Exp.fresh, + InvalidOperationError.DivideByZero, + ), + copied: false, +}; +let dynamic_error_hole_menhir = () => + alco_check_menhir( + "Dynamic error hole (menhir)", + dynamic_error_hole_str, + dynamic_error_hole_uexp, + ); let elaboration_tests = [ - // test_case("Type alias test (menhir)", `Quick, ty_alias_menhir), + test_case("Dynamic error hole (menhir)", `Quick, dynamic_error_hole_menhir), test_case("Constructor test (menhir)", `Quick, constructor_menhir), test_case("Failed cast test (menhir)", `Quick, failed_cast_menhir), test_case("Type ap test (menhir)", `Quick, typ_ap_menhir), From 5b71bd9738d725f11322d1729ec82a0ad4cc0de6 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 12 Aug 2024 14:37:34 -0400 Subject: [PATCH 040/281] Added in elaboration tests for undef, filter action, and builtin --- src/haz3lcore/statics/TermBase.re | 4 ++- src/haz3lmenhir/AST.re | 2 ++ src/haz3lmenhir/Lexer.mll | 4 +-- src/haz3lmenhir/Parser.mly | 5 +++- test/Test_Elaboration.re | 44 +++++++++++++++++++++++++++++++ 5 files changed, 55 insertions(+), 4 deletions(-) diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index eca3bdb4f2..9cd2510299 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -141,7 +141,7 @@ and Exp: { | DynamicErrorHole(t, InvalidOperationError.t) //This exp takes in the Sexp serialization of the InvalidOperationError.t as a string (s); // <> | FailedCast(t, Typ.t, Typ.t) //e ? ty2> | Deferral(deferral_position) /*InAp _*/ /*OutAp _*/ - | Undefined + | Undefined //undef | Bool(bool) //false | Int(int) //1 | Float(float) //1.0 @@ -279,12 +279,14 @@ and Exp: { Let(Pat.of_menhir_ast(p), of_menhir_ast(e1), of_menhir_ast(e2)) | FixF(p, e) => FixF(Pat.of_menhir_ast(p), of_menhir_ast(e), None) | TypFun(t, e) => TypFun(TPat.of_menhir_ast(t), of_menhir_ast(e), None) + | Undefined => Undefined | TyAlias(tp, ty, e) => TyAlias( TPat.of_menhir_ast(tp), Typ.of_menhir_ast(ty), of_menhir_ast(e), ) + | BuiltinFun(s) => BuiltinFun(s) | DeferredAp(f, a) => DeferredAp(of_menhir_ast(f), [of_menhir_ast(a)]) | Fun(p, e, name_opt) => switch (name_opt) { diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 6c67627b95..cbbfb26f4b 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -137,6 +137,8 @@ type exp = | MultiHole(exp) | EmptyHole | Filter(filter_action, exp, exp) + | BuiltinFun(string) + | Undefined | Seq(exp, exp) | Test(exp) | Deferral(deferral_pos) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index 8a63d2519c..b5e9ad2e08 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -25,10 +25,10 @@ let identifier = ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* let constructor_ident = ['A'-'Z'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* let sexp_string = '`' [^'`']* '`' -(* let builtins = ["infinity", "neg_infinity", "nan", "epsilon_float", "pi", "max_int", "min_int", "is_finite", "is_infinite", "int_of_float", "float_of_int", "string_of_int", "string_of_float", "string_of_bool", "int_of_string", "float_of_string", "bool_of_string", "abs", "abs_float", "ceil", "floor", "exp", "log", "log10", "sqrt", "sin", "cos", "tan", "asin", "acos", "atan", "mod", "string_length", "string_compare", "string_trim", "string_concat", "string_sub"] *) - rule token = parse + | "undef" { UNDEF} + | "infinity" | "neg_infinity" | "nan" | "epsilon_float" | "pi" | "max_int" | "min_int" | "is_finite" | "is_infinite" | "int_of_float" | "float_of_int" | "string_of_int" | "string_of_float" | "string_of_bool" | "int_of_string" | "float_of_string" | "bool_of_string" | "abs" | "abs_float" | "ceil" | "floor" | "exp" | "log" | "log10" | "sqrt" | "sin" | "cos" | "tan" | "asin" | "acos" | "atan" | "mod" | "string_length" | "string_compare" | "string_trim" | "string_concat" | "string_sub" { BUILTIN(Lexing.lexeme lexbuf)} | whitespace {token lexbuf } | newline { advance_line lexbuf; token lexbuf} | int as i { INT (int_of_string i) } diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 48eefad46c..362075a76f 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -2,6 +2,8 @@ open AST %} + +%token UNDEF %token SEXP_STRING %token DOLLAR_SIGN %token TYP @@ -249,5 +251,6 @@ exp: | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} | LESS_THAN; LESS_THAN; e = exp; QUESTION; s = SEXP_STRING; GREATER_THAN; GREATER_THAN {DynamicErrorHole(e, s)} - (* | b = BUILTIN; OPEN_PAREN; a = exp; CLOSE_PAREN {BuiltinAp(b, a)} *) + | b = BUILTIN; {BuiltinFun(b)} + | UNDEF; {Undefined} | u = unExp { u } diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 6b8dd74521..f9730a6ae9 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -272,7 +272,51 @@ let dynamic_error_hole_menhir = () => dynamic_error_hole_uexp, ); +let builtin_fun_str = "infinity"; +let builtin_fun_uexp: Exp.t = { + ids: [id_at(0)], + term: BuiltinFun("infinity"), + copied: false, +}; +let builtin_fun_menhir = () => + alco_check_menhir( + "Builtin function test (menhir)", + builtin_fun_str, + builtin_fun_uexp, + ); + +let undef_str = "undef"; +let undef_uexp: Exp.t = {ids: [id_at(0)], term: Undefined, copied: false}; +let undef_menhir = () => + alco_check_menhir("Undef test (menhir)", undef_str, undef_uexp); + +let test_str = "test 1 ? Bool> end"; +let test_uexp: Exp.t = { + ids: [id_at(0)], + term: Test(Int(1) |> Exp.fresh), + copied: false, +}; +let test_menhir = () => + alco_check_menhir("Test failed (menhir)", test_str, test_uexp); + +let filter_str = "eval 1 0"; +let stepper_filter_kind = + TermBase.StepperFilterKind.Filter({ + pat: Int(1) |> Exp.fresh, + act: (FilterAction.Eval, FilterAction.All), + }); +let filter_uexp: Exp.t = { + ids: [id_at(0)], + term: Filter(stepper_filter_kind, Int(0) |> Exp.fresh), + copied: false, +}; +let filter_menhir = () => + alco_check_menhir("Filter test (menhir)", filter_str, filter_uexp); + let elaboration_tests = [ + test_case("Filter test (menhir)", `Quick, filter_menhir), + test_case("Test failed (menhir)", `Quick, test_menhir), + test_case("Built-in function (menhir)", `Quick, builtin_fun_menhir), test_case("Dynamic error hole (menhir)", `Quick, dynamic_error_hole_menhir), test_case("Constructor test (menhir)", `Quick, constructor_menhir), test_case("Failed cast test (menhir)", `Quick, failed_cast_menhir), From dfa56afbbcb41f734eac353d760679a6777b636e Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Thu, 15 Aug 2024 19:51:08 -0400 Subject: [PATCH 041/281] Cleaned up some comments & updated the menhir parser tests --- src/haz3lcore/statics/TermBase.re | 16 +---- src/haz3lmenhir/Lexer.mll | 1 - test/Test_Menhir.re | 100 +++++------------------------- test/haz3ltest.re | 2 +- test/test.hazel | 13 ---- 5 files changed, 20 insertions(+), 112 deletions(-) delete mode 100644 test/test.hazel diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index 9cd2510299..7d2e060f35 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -137,7 +137,7 @@ and Exp: { type term = | Invalid(string) //? s | EmptyHole //? - | MultiHole(list(Any.t)) //<> //TODO: not necessary for parser - cyrus + | MultiHole(list(Any.t)) //<> | DynamicErrorHole(t, InvalidOperationError.t) //This exp takes in the Sexp serialization of the InvalidOperationError.t as a string (s); // <> | FailedCast(t, Typ.t, Typ.t) //e ? ty2> | Deferral(deferral_position) /*InAp _*/ /*OutAp _*/ @@ -294,20 +294,11 @@ and Exp: { Fun( Pat.of_menhir_ast(p), of_menhir_ast(e), - //TODO: closure environment None, Some(name_str ++ "+"), ) - | None => - Fun( - Pat.of_menhir_ast(p), - of_menhir_ast(e), - //TODO: closure environment - None, - None, - ) + | None => Fun(Pat.of_menhir_ast(p), of_menhir_ast(e), None, None) } - //TODO: pass ap direction | ApExp(e1, e2) => Ap(Operators.Forward, of_menhir_ast(e1), of_menhir_ast(e2)) | BinExp(e1, op, e2) => @@ -355,7 +346,6 @@ and Exp: { of_menhir_ast(e), InvalidOperationError.t_of_sexp(sexp_of_string(s)), ) - // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) }; } and of_menhir_ast = (exp: Haz3lmenhir.AST.exp): Exp.t => { @@ -641,7 +631,6 @@ and Pat: { MultiHole([Pat(p)]); | WildPat => Wild | ListPat(l) => ListLit(List.map(of_menhir_ast, l)) - // | _ => raise(Invalid_argument("Menhir AST -> DHPat not yet implemented")) }; } and of_menhir_ast = (pat: Haz3lmenhir.AST.pat): t => { @@ -840,7 +829,6 @@ and Typ: { | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) | ArrayType(t) => List(of_menhir_ast(t)) | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) - // | _ => raise(Invalid_argument("Menhir AST -> DHExp not yet implemented")) }; }; diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index b5e9ad2e08..4ecae39e16 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -115,7 +115,6 @@ rule token = | "typfun" {TYP_FUN} | "type" {TYP} | "$" {DOLLAR_SIGN} - (* | builtins as b {BUILIN(b)} *) | identifier as i { IDENT(i) } | constructor_ident as i { CONSTRUCTOR_IDENT(i)} | eof { EOF } diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index ad7e32f510..168b76d34c 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -1,28 +1,6 @@ open Haz3lmenhir; -// open Haz3lcore.DHExp; open Alcotest; -let test_file = "./test/test.hazel"; - -let read_whole_file = (filename): string => { - let ch = open_in_bin(filename); - let s = really_input_string(ch, in_channel_length(ch)); - close_in(ch); - s; -}; - -let file_contents = read_whole_file(test_file); - -// print_endline(AST.show_exp(Haz3lmenhir.Interface.parse_program(file_contents))); - -// let prog: AST.exp = Haz3lmenhir.Interface.parse_program(file_contents); - -// let dhexp = of_menhir_ast(prog); -// print_endline(show(dhexp)); - -// let pp_string ppf x = Fmt.pf ppf "%S" x in -// testable pp_string ( = ) - let testable_ast = testable(Fmt.using(AST.show_exp, Fmt.string), (==)); let parser_test = (a, expected, actual, ()) => @@ -33,64 +11,20 @@ let parser_test = (a, expected, actual, ()) => Haz3lmenhir.Interface.parse_program(actual), ); -// let bigger_expression = -// AST.Let( -// TypeAnn( -// VarPat("intsOneElseAdd"), -// ArrowType(TupleType([TupleType([IntType, IntType])]), IntType), -// ), -// Fun( -// TuplePat([VarPat("x"), VarPat("y")]), -// CaseExp( -// TupleExp([Var("x"), Var("y")]), -// [ -// (TuplePat([IntPat(1), IntPat(1)]), Int(1)), -// (VarPat("_"), BinExp(Var("x"), IntOp(Plus), Var("y"))), -// ], -// ), -// ), -// Let( -// TypeAnn( -// VarPat("ap_and_inc"), -// ArrowType( -// TupleType([ -// TupleType([ArrowType(TupleType([IntType, IntType]), IntType)]), -// IntType, -// ]), -// IntType, -// ), -// ), -// Fun( -// TuplePat([VarPat("f"), VarPat("x")]), -// BinExp( -// ApExp(Var("f"), TupleExp([Var("x"), Int(2)])), -// IntOp(Plus), -// Int(1), -// ), -// ), -// ApExp(Var("ap_and_inc"), TupleExp([Var("intsOneElseAdd"), Int(1)])), -// ), -// ); - -// let fun_exp = AST.Fun(IntType, VarPat("x"), Var("x"), None); -// -// let fun_str = "fun: Int x -> x"; -// -// let tests = [ -// test_case( -// "Integer Literal", -// `Quick, -// parser_test("Same Integer", Int(8), "8"), -// ), -// test_case("Fun", `Quick, parser_test("Fun", fun_exp, fun_str)), -// test_case( -// "String Literal", -// `Quick, -// parser_test("Same String", String("Hello World"), "\"Hello World\""), -// ), -// test_case( -// "Bigger expression", -// `Quick, -// parser_test("test.hazel contents", bigger_expression, file_contents), -// ), -// ]; +let fun_exp = AST.Fun(VarPat("x"), Var("x"), None); + +let fun_str = "fun x -> x"; + +let tests = [ + test_case( + "Integer Literal", + `Quick, + parser_test("Same Integer", Int(8), "8"), + ), + test_case("Fun", `Quick, parser_test("Fun", fun_exp, fun_str)), + test_case( + "String Literal", + `Quick, + parser_test("Same String", String("Hello World"), "\"Hello World\""), + ), +]; diff --git a/test/haz3ltest.re b/test/haz3ltest.re index 43e92fa01c..73ab90e875 100644 --- a/test/haz3ltest.re +++ b/test/haz3ltest.re @@ -6,7 +6,7 @@ let (suite, _) = "Dynamics", [ ("Elaboration", Test_Elaboration.elaboration_tests), - // ("Parser", Test_Menhir.tests), + ("Parser", Test_Menhir.tests), ], ); Junit.to_file(Junit.make([suite]), "junit_tests.xml"); diff --git a/test/test.hazel b/test/test.hazel deleted file mode 100644 index d444ef69a4..0000000000 --- a/test/test.hazel +++ /dev/null @@ -1,13 +0,0 @@ -let intsOneElseAdd: ((Int, Int)) -> Int = - fun (x, y) -> - case (x, y) - | (1, 1) => 1 - | _ => x + y - end -in - -let ap_and_inc: (((Int, Int) -> Int), Int) -> Int = - fun (f, x) -> f((x, 2)) + 1 -in - -ap_and_inc((intsOneElseAdd, 1)) From aefea80687439c9302d593d6401e895f0ea6852e Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sat, 17 Aug 2024 23:59:21 -0400 Subject: [PATCH 042/281] More merge cleanups --- src/haz3lcore/statics/TermBase.re | 2 -- test/Test_Elaboration.re | 17 ----------------- 2 files changed, 19 deletions(-) diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index 7d2e060f35..2280cc1867 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -977,8 +977,6 @@ and TPat: { | Var(string) and t = IdTagged.t(term); - // let term_of_menhir: Haz3lmenhir.AST.TPat - let map_term: ( ~f_exp: (Exp.t => Exp.t, Exp.t) => Exp.t=?, diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index f9730a6ae9..4f55c4c6ed 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -8,23 +8,6 @@ let dhexp_typ = testable(Fmt.using(Exp.show, Fmt.string), DHExp.fast_equal); let ids = List.init(12, _ => Id.mk()); let id_at = x => x |> List.nth(ids); -//Starts at 0 -let get_id_menhir_closure = (id_index: int) => { - let id_index = ref(id_index - 1); - (inc: bool) => { - print_endline( - "get id inc: " - ++ string_of_bool(inc) - ++ " " - ++ string_of_int(id_index^), - ); - if (inc) { - id_index := id_index^ + 1; - }; - id_at(id_index^); - }; -}; - let mk_map = CoreSettings.on |> Interface.Statics.mk_map; let dhexp_of_uexp = u => Elaborator.elaborate(mk_map(u), u) |> fst; let alco_check = dhexp_typ |> Alcotest.check; From d8bdd8fb7f80765c323aa4a4bcdc3438c04b5897 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 23 Aug 2024 15:16:53 -0400 Subject: [PATCH 043/281] Moved the menhir -> dhexp conversion logic to haz3lmenhir from haz3lcore --- src/haz3lcore/dune | 2 +- src/haz3lcore/dynamics/Elaborator.re | 6 +- src/haz3lcore/dynamics/FilterAction.re | 9 - src/haz3lcore/lang/Operators.re | 77 ------- src/haz3lcore/prog/Interface.re | 3 +- src/haz3lcore/statics/TermBase.re | 165 --------------- src/haz3lmenhir/Conversion.re | 268 +++++++++++++++++++++++++ src/haz3lmenhir/Lexer.mll | 3 - src/haz3lmenhir/Parser.mly | 6 +- src/haz3lmenhir/dune | 3 +- test/Test_Elaboration.re | 10 +- 11 files changed, 285 insertions(+), 267 deletions(-) create mode 100644 src/haz3lmenhir/Conversion.re diff --git a/src/haz3lcore/dune b/src/haz3lcore/dune index 60f37bb3c5..77e2ca3fe1 100644 --- a/src/haz3lcore/dune +++ b/src/haz3lcore/dune @@ -2,7 +2,7 @@ (library (name haz3lcore) - (libraries util sexplib unionFind uuidm virtual_dom yojson core haz3lmenhir) + (libraries util sexplib unionFind uuidm virtual_dom yojson core) (js_of_ocaml) (preprocess (pps diff --git a/src/haz3lcore/dynamics/Elaborator.re b/src/haz3lcore/dynamics/Elaborator.re index c1f3aa12d7..54602ffe6f 100644 --- a/src/haz3lcore/dynamics/Elaborator.re +++ b/src/haz3lcore/dynamics/Elaborator.re @@ -209,6 +209,8 @@ let rec elaborate = (m: Statics.Map.t, uexp: UExp.t): (DHExp.t, Typ.t) => { let (elaborated_type, ctx, co_ctx) = elaborated_type(m, uexp); let cast_from = (ty, exp) => fresh_cast(exp, ty, elaborated_type); let (term, rewrap) = UExp.unwrap(uexp); + print_endline("Elaborating"); + let dhexp = switch (term) { | Invalid(_) @@ -571,5 +573,7 @@ let fix_typ_ids = let uexp_elab = (m: Statics.Map.t, uexp: UExp.t): ElaborationResult.t => switch (elaborate(m, uexp)) { | exception MissingTypeInfo => DoesNotElaborate - | (d, ty) => Elaborates(d, ty, Delta.empty) + | (d, ty) => + print_endline("Elaborated: " ++ DHExp.show(d)); + Elaborates(d, ty, Delta.empty); }; diff --git a/src/haz3lcore/dynamics/FilterAction.re b/src/haz3lcore/dynamics/FilterAction.re index 8b57f4994b..6a4dce5ca3 100644 --- a/src/haz3lcore/dynamics/FilterAction.re +++ b/src/haz3lcore/dynamics/FilterAction.re @@ -19,12 +19,3 @@ let string_of_t = v => { | (Eval, All) => "eval" }; }; - -let of_menhir_ast = (a: Haz3lmenhir.AST.filter_action): t => { - switch (a) { - | Eval => (Eval, All) - | Pause => (Step, One) - | Debug => (Step, All) - | Hide => (Eval, One) - }; -}; diff --git a/src/haz3lcore/lang/Operators.re b/src/haz3lcore/lang/Operators.re index 9bf03e5804..aa8842b72b 100644 --- a/src/haz3lcore/lang/Operators.re +++ b/src/haz3lcore/lang/Operators.re @@ -54,32 +54,6 @@ type op_un = | Int(op_un_int) | Bool(op_un_bool); -let op_un_meta_of_menhir_ast = (op: Haz3lmenhir.AST.op_un_meta) => { - switch (op) { - | Unquote => Unquote - }; -}; - -let op_un_int_of_menhir_ast = (op: Haz3lmenhir.AST.op_un_int): op_un_int => { - switch (op) { - | Minus => Minus - }; -}; - -let op_un_bool_of_menhir_ast = (op: Haz3lmenhir.AST.op_un_bool): op_un_bool => { - switch (op) { - | Not => Not - }; -}; - -let op_un_of_menhir_ast = (op: Haz3lmenhir.AST.op_un): op_un => { - switch (op) { - | Meta(meta) => Meta(op_un_meta_of_menhir_ast(meta)) - | Int(i) => Int(op_un_int_of_menhir_ast(i)) - | Bool(b) => Bool(op_un_bool_of_menhir_ast(b)) - }; -}; - [@deriving (show({with_path: false}), sexp, yojson)] type op_bin = | Int(op_bin_int) @@ -87,57 +61,6 @@ type op_bin = | Bool(op_bin_bool) | String(op_bin_string); -[@deriving (show({with_path: false}), sexp, yojson)] -let float_op_of_menhir_ast = (op: Haz3lmenhir.AST.op_bin_float): op_bin_float => { - switch (op) { - | Plus => Plus - | Minus => Minus - | Times => Times - | Power => Power - | Divide => Divide - | LessThan => LessThan - | LessThanOrEqual => LessThanOrEqual - | GreaterThan => GreaterThan - | GreaterThanOrEqual => GreaterThanOrEqual - | Equals => Equals - | NotEquals => NotEquals - }; -}; - -[@deriving (show({with_path: false}), sexp, yojson)] -let bool_op_of_menhir_ast = (op: Haz3lmenhir.AST.op_bin_bool): op_bin_bool => { - switch (op) { - | And => And - | Or => Or - }; -}; - -[@deriving (show({with_path: false}), sexp, yojson)] -let int_op_of_menhir_ast = (op: Haz3lmenhir.AST.op_bin_int): op_bin_int => { - switch (op) { - | Plus => Plus - | Minus => Minus - | Times => Times - | Power => Power - | Divide => Divide - | LessThan => LessThan - | LessThanOrEqual => LessThanOrEqual - | GreaterThan => GreaterThan - | GreaterThanOrEqual => GreaterThanOrEqual - | Equals => Equals - | NotEquals => NotEquals - }; -}; - -[@deriving (show({with_path: false}), sexp, yojson)] -let of_menhir_ast = (op: Haz3lmenhir.AST.binOp): op_bin => { - switch (op) { - | IntOp(op_int) => Int(int_op_of_menhir_ast(op_int)) - | FloatOp(op_float) => Float(float_op_of_menhir_ast(op_float)) - | BoolOp(op_bool) => Bool(bool_op_of_menhir_ast(op_bool)) - }; -}; - [@deriving (show({with_path: false}), sexp, yojson)] type ap_direction = | Forward diff --git a/src/haz3lcore/prog/Interface.re b/src/haz3lcore/prog/Interface.re index 3249b1aef2..1d6f881d27 100644 --- a/src/haz3lcore/prog/Interface.re +++ b/src/haz3lcore/prog/Interface.re @@ -18,7 +18,7 @@ let elaborate = (~settings: CoreSettings.t, map, term): DHExp.t => let evaluate = (~settings: CoreSettings.t, ~env=Builtins.env_init, elab: DHExp.t) - : ProgramResult.t => + : ProgramResult.t => { switch () { | _ when !settings.dynamics => Off({d: elab}) | _ => @@ -32,3 +32,4 @@ let evaluate = | (state, result) => ResultOk({result, state}) } }; +}; diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index 2280cc1867..728feb88c1 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -200,9 +200,6 @@ and Exp: { t; let fast_equal: (t, t) => bool; - - let term_of_menhir_ast: Haz3lmenhir.AST.exp => Exp.term; - let of_menhir_ast: Haz3lmenhir.AST.exp => Exp.t; } = { [@deriving (show({with_path: false}), sexp, yojson)] type deferral_position = @@ -254,104 +251,6 @@ and Exp: { | Cast(t, Typ.t, Typ.t) and t = IdTagged.t(term); - let rec term_of_menhir_ast = (exp: Haz3lmenhir.AST.exp): Exp.term => { - switch (exp) { - | InvalidExp(s) => Invalid(s) - | Int(i) => Int(i) - | Float(f) => Float(f) - | String(s) => String(s) - | Bool(b) => Bool(b) - | Var(x) => Var(x) - | Constructor(x, ty) => Constructor(x, Typ.of_menhir_ast(ty)) - | Deferral(pos) => - switch (pos) { - | InAp => Deferral(InAp) - | OutsideAp => Deferral(OutsideAp) - } - | ListExp(l) => ListLit(List.map(of_menhir_ast, l)) - | TupleExp(t) => - if (List.length(t) == 1) { - Parens(of_menhir_ast(List.hd(t))); - } else { - Tuple(List.map(of_menhir_ast, t)); - } - | Let(p, e1, e2) => - Let(Pat.of_menhir_ast(p), of_menhir_ast(e1), of_menhir_ast(e2)) - | FixF(p, e) => FixF(Pat.of_menhir_ast(p), of_menhir_ast(e), None) - | TypFun(t, e) => TypFun(TPat.of_menhir_ast(t), of_menhir_ast(e), None) - | Undefined => Undefined - | TyAlias(tp, ty, e) => - TyAlias( - TPat.of_menhir_ast(tp), - Typ.of_menhir_ast(ty), - of_menhir_ast(e), - ) - | BuiltinFun(s) => BuiltinFun(s) - | DeferredAp(f, a) => DeferredAp(of_menhir_ast(f), [of_menhir_ast(a)]) - | Fun(p, e, name_opt) => - switch (name_opt) { - | Some(name_str) => - Fun( - Pat.of_menhir_ast(p), - of_menhir_ast(e), - None, - Some(name_str ++ "+"), - ) - | None => Fun(Pat.of_menhir_ast(p), of_menhir_ast(e), None, None) - } - | ApExp(e1, e2) => - Ap(Operators.Forward, of_menhir_ast(e1), of_menhir_ast(e2)) - | BinExp(e1, op, e2) => - BinOp( - Operators.of_menhir_ast(op), - of_menhir_ast(e1), - of_menhir_ast(e2), - ) - - | If(e1, e2, e3) => - If(of_menhir_ast(e1), of_menhir_ast(e2), of_menhir_ast(e3)) - | CaseExp(e, l) => - let d_scrut = of_menhir_ast(e); - let d_rules = - List.map( - ((pat, exp)) => (Pat.of_menhir_ast(pat), of_menhir_ast(exp)), - l, - ); - Match(d_scrut, d_rules); - | Cast(e, t1, t2) => - Cast(of_menhir_ast(e), Typ.of_menhir_ast(t1), Typ.of_menhir_ast(t2)) - | FailedCast(e, t1, t2) => - FailedCast( - of_menhir_ast(e), - Typ.of_menhir_ast(t1), - Typ.of_menhir_ast(t2), - ) - | EmptyHole => EmptyHole - | Seq(e1, e2) => Seq(of_menhir_ast(e1), of_menhir_ast(e2)) - | Test(e) => Test(of_menhir_ast(e)) - | Cons(e1, e2) => Cons(of_menhir_ast(e1), of_menhir_ast(e2)) - | ListConcat(e1, e2) => - ListConcat(of_menhir_ast(e1), of_menhir_ast(e2)) - | Filter(a, cond, body) => - let dcond = of_menhir_ast(cond); - let dbody = of_menhir_ast(body); - let act = FilterAction.of_menhir_ast(a); - Filter(StepperFilterKind.Filter({pat: dcond, act}), dbody); - | MultiHole(e) => MultiHole([Exp(of_menhir_ast(e))]) - | TypAp(e, ty) => TypAp(of_menhir_ast(e), Typ.of_menhir_ast(ty)) - | UnOp(op, e) => - UnOp(Operators.op_un_of_menhir_ast(op), of_menhir_ast(e)) - | DynamicErrorHole(e, s) => - DynamicErrorHole( - of_menhir_ast(e), - InvalidOperationError.t_of_sexp(sexp_of_string(s)), - ) - }; - } - and of_menhir_ast = (exp: Haz3lmenhir.AST.exp): Exp.t => { - IdTagged.fresh(term_of_menhir_ast(exp)); - }; - let map_term = ( ~f_exp=continue, @@ -589,9 +488,6 @@ and Pat: { t; let fast_equal: (t, t) => bool; - - let term_of_menhir_ast: Haz3lmenhir.AST.pat => term; - let of_menhir_ast: Haz3lmenhir.AST.pat => t; } = { [@deriving (show({with_path: false}), sexp, yojson)] type term = @@ -613,30 +509,6 @@ and Pat: { | Cast(t, Typ.t, Typ.t) // The second one is hidden from the user and t = IdTagged.t(term); - let rec term_of_menhir_ast = (pat: Haz3lmenhir.AST.pat): term => { - switch (pat) { - | InvalidPat(s) => Invalid(s) - | IntPat(i) => Int(i) - | FloatPat(f) => Float(f) - | VarPat(x) => Var(x) - | ConstructorPat(x, ty) => Constructor(x, Typ.of_menhir_ast(ty)) - | StringPat(s) => String(s) - | TuplePat(pats) => Tuple(List.map(of_menhir_ast, pats)) - | ApPat(pat1, pat2) => Ap(of_menhir_ast(pat1), of_menhir_ast(pat2)) - | ConsPat(p1, p2) => Cons(of_menhir_ast(p1), of_menhir_ast(p2)) - | BoolPat(b) => Bool(b) - | EmptyHolePat => EmptyHole - | MultiHolePat(p) => - let p = of_menhir_ast(p); - MultiHole([Pat(p)]); - | WildPat => Wild - | ListPat(l) => ListLit(List.map(of_menhir_ast, l)) - }; - } - and of_menhir_ast = (pat: Haz3lmenhir.AST.pat): t => { - IdTagged.fresh(term_of_menhir_ast(pat)); - }; - let map_term = ( ~f_exp=continue, @@ -774,8 +646,6 @@ and Typ: { let subst: (t, TPat.t, t) => t; let fast_equal: (t, t) => bool; - - let of_menhir_ast: Haz3lmenhir.AST.typ => t; } = { [@deriving (show({with_path: false}), sexp, yojson)] type type_hole = @@ -811,27 +681,6 @@ and Typ: { | Forall(TPat.t, t) and t = IdTagged.t(term); - let rec of_menhir_ast = (typ: Haz3lmenhir.AST.typ): t => { - IdTagged.fresh(term_of_menhir_ast(typ)); - } - and term_of_menhir_ast = (typ: Haz3lmenhir.AST.typ): term => { - switch (typ) { - | InvalidTyp(s) => Unknown(Hole(Invalid(s))) - | IntType => Int - | FloatType => Float - | BoolType => Bool - | StringType => String - | UnitType => Prod([]) - | UnknownType(p) => - switch (p) { - | Internal => Unknown(Internal) - } - | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) - | ArrayType(t) => List(of_menhir_ast(t)) - | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) - }; - }; - type sum_map = ConstructorMap.t(t); let map_term = @@ -992,8 +841,6 @@ and TPat: { let tyvar_of_utpat: t => option(string); let fast_equal: (t, t) => bool; - let of_menhir_ast: Haz3lmenhir.AST.tpat => t; - let term_of_menhir_ast: Haz3lmenhir.AST.tpat => term; } = { [@deriving (show({with_path: false}), sexp, yojson)] type term = @@ -1003,18 +850,6 @@ and TPat: { | Var(string) and t = IdTagged.t(term); - let rec term_of_menhir_ast = (tpat: Haz3lmenhir.AST.tpat) => { - switch (tpat) { - | InvalidTPat(s) => Invalid(s) - | EmptyHoleTPat => EmptyHole - | MultiHoleTPat(t) => MultiHole([TPat(of_menhir_ast(t))]) - | VarTPat(s) => Var(s) - }; - } - and of_menhir_ast = (tpat: Haz3lmenhir.AST.tpat) => { - IdTagged.fresh(term_of_menhir_ast(tpat)); - }; - let map_term = ( ~f_exp=continue, diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re new file mode 100644 index 0000000000..d1ffaa662c --- /dev/null +++ b/src/haz3lmenhir/Conversion.re @@ -0,0 +1,268 @@ +include Sexplib.Std; + +module FilterAction = { + open Haz3lcore.FilterAction; + let of_menhir_ast = (a: AST.filter_action): t => { + switch (a) { + | Eval => (Eval, All) + | Pause => (Step, One) + | Debug => (Step, All) + | Hide => (Eval, One) + }; + }; +}; + +module Operators = { + open Haz3lcore.Operators; + + let op_un_meta_of_menhir_ast = (op: AST.op_un_meta) => { + switch (op) { + | Unquote => Unquote + }; + }; + + let op_un_int_of_menhir_ast = (op: AST.op_un_int): op_un_int => { + switch (op) { + | Minus => Minus + }; + }; + + let op_un_bool_of_menhir_ast = (op: AST.op_un_bool): op_un_bool => { + switch (op) { + | Not => Not + }; + }; + + let op_un_of_menhir_ast = (op: AST.op_un): op_un => { + switch (op) { + | Meta(meta) => Meta(op_un_meta_of_menhir_ast(meta)) + | Int(i) => Int(op_un_int_of_menhir_ast(i)) + | Bool(b) => Bool(op_un_bool_of_menhir_ast(b)) + }; + }; + + [@deriving (show({with_path: false}), sexp, yojson)] + let float_op_of_menhir_ast = (op: AST.op_bin_float): op_bin_float => { + switch (op) { + | Plus => Plus + | Minus => Minus + | Times => Times + | Power => Power + | Divide => Divide + | LessThan => LessThan + | LessThanOrEqual => LessThanOrEqual + | GreaterThan => GreaterThan + | GreaterThanOrEqual => GreaterThanOrEqual + | Equals => Equals + | NotEquals => NotEquals + }; + }; + + [@deriving (show({with_path: false}), sexp, yojson)] + let bool_op_of_menhir_ast = (op: AST.op_bin_bool): op_bin_bool => { + switch (op) { + | And => And + | Or => Or + }; + }; + + [@deriving (show({with_path: false}), sexp, yojson)] + let int_op_of_menhir_ast = (op: AST.op_bin_int): op_bin_int => { + switch (op) { + | Plus => Plus + | Minus => Minus + | Times => Times + | Power => Power + | Divide => Divide + | LessThan => LessThan + | LessThanOrEqual => LessThanOrEqual + | GreaterThan => GreaterThan + | GreaterThanOrEqual => GreaterThanOrEqual + | Equals => Equals + | NotEquals => NotEquals + }; + }; + + [@deriving (show({with_path: false}), sexp, yojson)] + let of_menhir_ast = (op: AST.binOp): op_bin => { + switch (op) { + | IntOp(op_int) => Int(int_op_of_menhir_ast(op_int)) + | FloatOp(op_float) => Float(float_op_of_menhir_ast(op_float)) + | BoolOp(op_bool) => Bool(bool_op_of_menhir_ast(op_bool)) + }; + }; +}; + +module rec Exp: { + let term_of_menhir_ast: AST.exp => Haz3lcore.Exp.term; + let of_menhir_ast: AST.exp => Haz3lcore.Exp.t; +} = { + let rec term_of_menhir_ast = (exp: AST.exp): Haz3lcore.Exp.term => { + switch (exp) { + | InvalidExp(s) => Invalid(s) + | Int(i) => Int(i) + | Float(f) => Float(f) + | String(s) => String(s) + | Bool(b) => Bool(b) + | Var(x) => Var(x) + | Constructor(x, ty) => Constructor(x, Typ.of_menhir_ast(ty)) + | Deferral(pos) => + switch (pos) { + | InAp => Deferral(InAp) + | OutsideAp => Deferral(OutsideAp) + } + | ListExp(l) => ListLit(List.map(of_menhir_ast, l)) + | TupleExp(t) => + if (List.length(t) == 1) { + Parens(of_menhir_ast(List.hd(t))); + } else { + Tuple(List.map(of_menhir_ast, t)); + } + | Let(p, e1, e2) => + Let(Pat.of_menhir_ast(p), of_menhir_ast(e1), of_menhir_ast(e2)) + | FixF(p, e) => FixF(Pat.of_menhir_ast(p), of_menhir_ast(e), None) + | TypFun(t, e) => TypFun(TPat.of_menhir_ast(t), of_menhir_ast(e), None) + | Undefined => Undefined + | TyAlias(tp, ty, e) => + TyAlias( + TPat.of_menhir_ast(tp), + Typ.of_menhir_ast(ty), + of_menhir_ast(e), + ) + | BuiltinFun(s) => BuiltinFun(s) + | DeferredAp(f, a) => DeferredAp(of_menhir_ast(f), [of_menhir_ast(a)]) + | Fun(p, e, name_opt) => + switch (name_opt) { + | Some(name_str) => + Fun( + Pat.of_menhir_ast(p), + of_menhir_ast(e), + None, + Some(name_str ++ "+"), + ) + | None => Fun(Pat.of_menhir_ast(p), of_menhir_ast(e), None, None) + } + | ApExp(e1, e2) => + Ap(Haz3lcore.Operators.Forward, of_menhir_ast(e1), of_menhir_ast(e2)) + | BinExp(e1, op, e2) => + BinOp( + Operators.of_menhir_ast(op), + of_menhir_ast(e1), + of_menhir_ast(e2), + ) + + | If(e1, e2, e3) => + If(of_menhir_ast(e1), of_menhir_ast(e2), of_menhir_ast(e3)) + | CaseExp(e, l) => + let d_scrut = of_menhir_ast(e); + let d_rules = + List.map( + ((pat, exp)) => (Pat.of_menhir_ast(pat), of_menhir_ast(exp)), + l, + ); + Match(d_scrut, d_rules); + | Cast(e, t1, t2) => + Cast(of_menhir_ast(e), Typ.of_menhir_ast(t1), Typ.of_menhir_ast(t2)) + | FailedCast(e, t1, t2) => + FailedCast( + of_menhir_ast(e), + Typ.of_menhir_ast(t1), + Typ.of_menhir_ast(t2), + ) + | EmptyHole => EmptyHole + | Seq(e1, e2) => Seq(of_menhir_ast(e1), of_menhir_ast(e2)) + | Test(e) => Test(of_menhir_ast(e)) + | Cons(e1, e2) => Cons(of_menhir_ast(e1), of_menhir_ast(e2)) + | ListConcat(e1, e2) => + ListConcat(of_menhir_ast(e1), of_menhir_ast(e2)) + | Filter(a, cond, body) => + let dcond = of_menhir_ast(cond); + let dbody = of_menhir_ast(body); + let act = FilterAction.of_menhir_ast(a); + Filter( + Haz3lcore.TermBase.StepperFilterKind.Filter({pat: dcond, act}), + dbody, + ); + | MultiHole(e) => MultiHole([Exp(of_menhir_ast(e))]) + | TypAp(e, ty) => TypAp(of_menhir_ast(e), Typ.of_menhir_ast(ty)) + | UnOp(op, e) => + UnOp(Operators.op_un_of_menhir_ast(op), of_menhir_ast(e)) + | DynamicErrorHole(e, s) => + DynamicErrorHole( + of_menhir_ast(e), + Haz3lcore.InvalidOperationError.t_of_sexp(sexp_of_string(s)), + ) + }; + } + and of_menhir_ast = (exp: AST.exp): Haz3lcore.Exp.t => { + Haz3lcore.IdTagged.fresh(term_of_menhir_ast(exp)); + }; +} +and Typ: { + let of_menhir_ast: AST.typ => Haz3lcore.Typ.t; +} = { + let rec of_menhir_ast = (typ: AST.typ): Haz3lcore.Typ.t => { + Haz3lcore.IdTagged.fresh(term_of_menhir_ast(typ)); + } + and term_of_menhir_ast = (typ: AST.typ): Haz3lcore.Typ.term => { + switch (typ) { + | InvalidTyp(s) => Unknown(Hole(Invalid(s))) + | IntType => Int + | FloatType => Float + | BoolType => Bool + | StringType => String + | UnitType => Prod([]) + | UnknownType(p) => + switch (p) { + | Internal => Unknown(Internal) + } + | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) + | ArrayType(t) => List(of_menhir_ast(t)) + | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) + }; + }; +} +and TPat: { + let of_menhir_ast: AST.tpat => Haz3lcore.TPat.t; + let term_of_menhir_ast: AST.tpat => Haz3lcore.TPat.term; +} = { + let rec term_of_menhir_ast = (tpat: AST.tpat): Haz3lcore.TPat.term => { + switch (tpat) { + | InvalidTPat(s) => Invalid(s) + | EmptyHoleTPat => EmptyHole + | MultiHoleTPat(t) => MultiHole([TPat(of_menhir_ast(t))]) + | VarTPat(s) => Var(s) + }; + } + and of_menhir_ast = (tpat: AST.tpat) => { + Haz3lcore.IdTagged.fresh(term_of_menhir_ast(tpat)); + }; +} +and Pat: { + let term_of_menhir_ast: AST.pat => Haz3lcore.Pat.term; + let of_menhir_ast: AST.pat => Haz3lcore.Pat.t; +} = { + let rec term_of_menhir_ast = (pat: AST.pat): Haz3lcore.Pat.term => { + switch (pat) { + | InvalidPat(s) => Invalid(s) + | IntPat(i) => Int(i) + | FloatPat(f) => Float(f) + | VarPat(x) => Var(x) + | ConstructorPat(x, ty) => Constructor(x, Typ.of_menhir_ast(ty)) + | StringPat(s) => String(s) + | TuplePat(pats) => Tuple(List.map(of_menhir_ast, pats)) + | ApPat(pat1, pat2) => Ap(of_menhir_ast(pat1), of_menhir_ast(pat2)) + | ConsPat(p1, p2) => Cons(of_menhir_ast(p1), of_menhir_ast(p2)) + | BoolPat(b) => Bool(b) + | EmptyHolePat => EmptyHole + | MultiHolePat(p) => + let p = of_menhir_ast(p); + MultiHole([Pat(p)]); + | WildPat => Wild + | ListPat(l) => ListLit(List.map(of_menhir_ast, l)) + }; + } + and of_menhir_ast = (pat: AST.pat): Haz3lcore.Pat.t => { + Haz3lcore.IdTagged.fresh(term_of_menhir_ast(pat)); + }; +}; diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index 4ecae39e16..dbbdfb2174 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -45,7 +45,6 @@ rule token = | "if" { IF } | "then" { THEN } | "else" { ELSE } - | "as" { AS } | "{" { OPEN_BRACKET } | "}" { CLOSE_BRACKET } | "[" { OPEN_SQUARE_BRACKET } @@ -83,7 +82,6 @@ rule token = | "&&" { L_AND } | "||" { L_OR } | "!" { L_NOT } - | "&" { B_AND } | "|" { TURNSTILE } | "," { COMMA } | ":" { COLON } @@ -108,7 +106,6 @@ rule token = | "@" {AT_SYMBOL} | "?" {QUESTION} | "_" {WILD} - | "_BAD" {BAD_CONSTRUCTOR} | "fix" {FIX} | "_InAp" {IN_AP} | "_OutAp" {OUT_AP} diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 362075a76f..4b49c5808b 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -11,7 +11,6 @@ open AST %token IN_AP %token OUT_AP %token FIX -%token BAD_CONSTRUCTOR %token WILD %token QUESTION %token AT_SYMBOL @@ -32,7 +31,6 @@ open AST %token LET %token FUN %token CASE -%token AS %token OPEN_BRACKET %token CLOSE_BRACKET %token OPEN_SQUARE_BRACKET @@ -73,8 +71,6 @@ open AST %token L_OR %token L_NOT (*bitwise ops*) -%token B_AND - %token COMMA %token COLON %token EOF @@ -94,6 +90,8 @@ open AST %token THEN %token ELSE + + %token SEMI_COLON %type exp diff --git a/src/haz3lmenhir/dune b/src/haz3lmenhir/dune index 0dbb862857..212543341a 100644 --- a/src/haz3lmenhir/dune +++ b/src/haz3lmenhir/dune @@ -1,6 +1,7 @@ (library (name haz3lmenhir) - (libraries util re sexplib unionFind) + (libraries util re sexplib unionFind haz3lcore) + (modules AST Conversion Interface Lexer Parser) (preprocess (pps ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index c5baa9c7d3..8fd38d487f 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -15,7 +15,7 @@ let alco_check = dhexp_typ |> Alcotest.check; let alco_check_menhir = (name: string, dhexp: string, uexp: Term.Exp.t) => alco_check( name, - Haz3lcore.TermBase.Exp.of_menhir_ast( + Haz3lmenhir.Conversion.Exp.of_menhir_ast( Haz3lmenhir.Interface.parse_program(dhexp), ), dhexp_of_uexp(uexp), @@ -75,7 +75,7 @@ let free_var_uexp: Exp.t = { let free_var_menhir = () => alco_check( "Nonempty hole with free variable (menhir)", - Haz3lcore.TermBase.Exp.of_menhir_ast( + Haz3lmenhir.Conversion.Exp.of_menhir_ast( Haz3lmenhir.Interface.parse_program("y"), ), dhexp_of_uexp(free_var_uexp), @@ -91,7 +91,7 @@ let bin_op_str = "false? Int> + y Int>"; let bin_op_menhir = () => alco_check( "Inconsistent binary integer operation (plus)", - Haz3lcore.DHExp.of_menhir_ast( + Haz3lmenhir.Conversion.Exp.of_menhir_ast( Haz3lmenhir.Interface.parse_program(bin_op_str), ), dhexp_of_uexp(bin_op_uexp), @@ -143,7 +143,7 @@ let ap_fun_str = " let ap_fun_menhir = () => alco_check( "Application of a function (menhir)", - Haz3lcore.DHExp.of_menhir_ast( + Haz3lmenhir.Conversion.Exp.of_menhir_ast( Haz3lmenhir.Interface.parse_program(ap_fun_str), ), dhexp_of_uexp(ap_fun_uexp), @@ -160,7 +160,7 @@ let consistent_if_str = " let consistent_if_menhir = () => alco_check( "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", - Haz3lcore.DHExp.of_menhir_ast( + Haz3lmenhir.Conversion.Exp.of_menhir_ast( Haz3lmenhir.Interface.parse_program(consistent_if_str), ), dhexp_of_uexp(consistent_if_uexp), From ffe5ef9806e53f49ea3638e3941ec997d770070b Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 26 Aug 2024 23:08:38 -0400 Subject: [PATCH 044/281] Removed MultiHoles from the Menhir parser --- src/haz3lmenhir/AST.re | 3 --- src/haz3lmenhir/Conversion.re | 5 ----- src/haz3lmenhir/Lexer.mll | 2 -- src/haz3lmenhir/Parser.mly | 6 +----- 4 files changed, 1 insertion(+), 15 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index cbbfb26f4b..db7d90b00c 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -85,7 +85,6 @@ type typ = type pat = | EmptyHolePat | WildPat - | MultiHolePat(pat) | IntPat(int) | FloatPat(float) | VarPat(string) @@ -112,7 +111,6 @@ type deferral_pos = type tpat = | InvalidTPat(string) | EmptyHoleTPat - | MultiHoleTPat(tpat) | VarTPat(string); [@deriving (show({with_path: false}), sexp)] @@ -134,7 +132,6 @@ type exp = | Bool(bool) | Cast(exp, typ, typ) | FailedCast(exp, typ, typ) - | MultiHole(exp) | EmptyHole | Filter(filter_action, exp, exp) | BuiltinFun(string) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index d1ffaa662c..40e5f55635 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -183,7 +183,6 @@ module rec Exp: { Haz3lcore.TermBase.StepperFilterKind.Filter({pat: dcond, act}), dbody, ); - | MultiHole(e) => MultiHole([Exp(of_menhir_ast(e))]) | TypAp(e, ty) => TypAp(of_menhir_ast(e), Typ.of_menhir_ast(ty)) | UnOp(op, e) => UnOp(Operators.op_un_of_menhir_ast(op), of_menhir_ast(e)) @@ -230,7 +229,6 @@ and TPat: { switch (tpat) { | InvalidTPat(s) => Invalid(s) | EmptyHoleTPat => EmptyHole - | MultiHoleTPat(t) => MultiHole([TPat(of_menhir_ast(t))]) | VarTPat(s) => Var(s) }; } @@ -255,9 +253,6 @@ and Pat: { | ConsPat(p1, p2) => Cons(of_menhir_ast(p1), of_menhir_ast(p2)) | BoolPat(b) => Bool(b) | EmptyHolePat => EmptyHole - | MultiHolePat(p) => - let p = of_menhir_ast(p); - MultiHole([Pat(p)]); | WildPat => Wild | ListPat(l) => ListLit(List.map(of_menhir_ast, l)) }; diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index dbbdfb2174..e59b72f3da 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -45,8 +45,6 @@ rule token = | "if" { IF } | "then" { THEN } | "else" { ELSE } - | "{" { OPEN_BRACKET } - | "}" { CLOSE_BRACKET } | "[" { OPEN_SQUARE_BRACKET } | "]" { CLOSE_SQUARE_BRACKET } | "(" { OPEN_PAREN } diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 4b49c5808b..16ca41f077 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -3,6 +3,7 @@ open AST %} + %token UNDEF %token SEXP_STRING %token DOLLAR_SIGN @@ -31,8 +32,6 @@ open AST %token LET %token FUN %token CASE -%token OPEN_BRACKET -%token CLOSE_BRACKET %token OPEN_SQUARE_BRACKET %token CLOSE_SQUARE_BRACKET %token OPEN_PAREN @@ -159,7 +158,6 @@ varPat: pat: | QUESTION; s = STRING { InvalidPat(s) } - | OPEN_BRACKET; OPEN_BRACKET; p = pat; CLOSE_BRACKET; CLOSE_BRACKET; {MultiHolePat p} | WILD { WildPat } | QUESTION { EmptyHolePat } | OPEN_SQUARE_BRACKET; l = separated_list(COMMA, pat); CLOSE_SQUARE_BRACKET; { ListPat(l) } @@ -206,7 +204,6 @@ filterAction: tpat: | QUESTION; s = STRING {InvalidTPat(s)} | QUESTION {EmptyHoleTPat} - | OPEN_BRACKET; OPEN_BRACKET; t = tpat; CLOSE_BRACKET; CLOSE_BRACKET; {MultiHoleTPat t} | v = IDENT {VarTPat v} unExp: @@ -236,7 +233,6 @@ exp: | FALSE { Bool false } | FIX; p = pat; DASH_ARROW; e = exp { FixF(p, e) } | TYP_FUN; t = tpat; DASH_ARROW; e = exp {TypFun(t, e)} - | LESS_THAN; LESS_THAN; e = exp; GREATER_THAN; GREATER_THAN {MultiHole e} | QUESTION { EmptyHole } | a = filterAction; cond = exp; body = exp { Filter(a, cond, body)} | TEST; e = exp; END { Test(e) } From 47ffe3e8a7cbb5b07ca2dad18831de91a418034c Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 6 Sep 2024 23:14:41 -0400 Subject: [PATCH 045/281] Resolved about 50% of the shift/reduce conflicts in the menhir parser --- src/haz3lcore/statics/TermBase.re | 2 +- src/haz3lmenhir/AST.re | 2 +- src/haz3lmenhir/Conversion.re | 6 +- src/haz3lmenhir/Parser.automaton | 2225 +++++++++++++++++++++++++++++ src/haz3lmenhir/Parser.conflicts | 332 +++++ src/haz3lmenhir/Parser.mly | 96 +- src/haz3lmenhir/dune | 3 +- test/Test_Elaboration.re | 6 - 8 files changed, 2623 insertions(+), 49 deletions(-) create mode 100644 src/haz3lmenhir/Parser.automaton create mode 100644 src/haz3lmenhir/Parser.conflicts diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index 728feb88c1..fed024f04a 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -162,7 +162,7 @@ and Exp: { | TyAlias(TPat.t, Typ.t, t) //type tp = ty in e | Ap(Operators.ap_direction, t, t) //e1(e2) | TypAp(t, Typ.t) /*e @ */ - | DeferredAp(t, list(t)) //_e1(e2) + | DeferredAp(t, list(t)) //e1(_e2) | If(t, t, t) //if e1 then e2 else e3 | Seq(t, t) //e1;e2 | Test(t) //test e end diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index db7d90b00c..69fa7dc876 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -145,6 +145,6 @@ type exp = | If(exp, exp, exp) | InvalidExp(string) | TypAp(exp, typ) - | DeferredAp(exp, exp) + | DeferredAp(exp) | DynamicErrorHole(exp, string) | TyAlias(tpat, typ, exp); diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 40e5f55635..9ff78b0390 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -130,7 +130,11 @@ module rec Exp: { of_menhir_ast(e), ) | BuiltinFun(s) => BuiltinFun(s) - | DeferredAp(f, a) => DeferredAp(of_menhir_ast(f), [of_menhir_ast(a)]) + | DeferredAp(f) => + switch (f) { + | ApExp(fn, a) => DeferredAp(of_menhir_ast(fn), [of_menhir_ast(a)]) + | _ => raise(Invalid_argument("Expected ApExp")) + } | Fun(p, e, name_opt) => switch (name_opt) { | Some(name_str) => diff --git a/src/haz3lmenhir/Parser.automaton b/src/haz3lmenhir/Parser.automaton new file mode 100644 index 0000000000..89329e2b8a --- /dev/null +++ b/src/haz3lmenhir/Parser.automaton @@ -0,0 +1,2225 @@ +State 0: +## Known stack suffix: +## +## LR(1) items: +program' -> . program [ # ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On program shift to state 127 +-- On exp shift to state 128 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 1: +## Known stack suffix: +## STRING +## LR(1) items: +exp -> STRING . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> STRING + +State 2: +## Known stack suffix: +## OPEN_SQUARE_BRACKET +## LR(1) items: +exp -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On separated_nonempty_list(COMMA,exp) shift to state 118 +-- On loption(separated_nonempty_list(COMMA,exp)) shift to state 125 +-- On exp shift to state 121 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: +-- On CLOSE_SQUARE_BRACKET +-- reduce production loption(separated_nonempty_list(COMMA,exp)) -> + +State 3: +## Known stack suffix: +## OPEN_PAREN +## LR(1) items: +exp -> OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> OPEN_PAREN . exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 116 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 4: +## Known stack suffix: +## LET +## LR(1) items: +exp -> LET . pat SINGLE_EQUAL exp IN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 5 +-- On TRUE shift to state 6 +-- On STRING shift to state 7 +-- On QUESTION shift to state 8 +-- On OPEN_SQUARE_BRACKET shift to state 10 +-- On OPEN_PAREN shift to state 11 +-- On INT shift to state 12 +-- On IDENT shift to state 13 +-- On FLOAT shift to state 14 +-- On FALSE shift to state 15 +-- On CONSTRUCTOR_IDENT shift to state 16 +-- On varPat shift to state 40 +-- On patTuple shift to state 42 +-- On pat shift to state 55 +## Reductions: + +State 5: +## Known stack suffix: +## WILD +## LR(1) items: +pat -> WILD . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> WILD + +State 6: +## Known stack suffix: +## TRUE +## LR(1) items: +pat -> TRUE . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> TRUE + +State 7: +## Known stack suffix: +## STRING +## LR(1) items: +pat -> STRING . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> STRING + +State 8: +## Known stack suffix: +## QUESTION +## LR(1) items: +pat -> QUESTION . STRING [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> QUESTION . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 9 +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> QUESTION + +State 9: +## Known stack suffix: +## QUESTION STRING +## LR(1) items: +pat -> QUESTION STRING . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> QUESTION STRING + +State 10: +## Known stack suffix: +## OPEN_SQUARE_BRACKET +## LR(1) items: +pat -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 5 +-- On TRUE shift to state 6 +-- On STRING shift to state 7 +-- On QUESTION shift to state 8 +-- On OPEN_SQUARE_BRACKET shift to state 10 +-- On OPEN_PAREN shift to state 11 +-- On INT shift to state 12 +-- On IDENT shift to state 13 +-- On FLOAT shift to state 14 +-- On FALSE shift to state 15 +-- On CONSTRUCTOR_IDENT shift to state 16 +-- On varPat shift to state 40 +-- On separated_nonempty_list(COMMA,pat) shift to state 41 +-- On patTuple shift to state 42 +-- On pat shift to state 43 +-- On loption(separated_nonempty_list(COMMA,pat)) shift to state 53 +## Reductions: +-- On CLOSE_SQUARE_BRACKET +-- reduce production loption(separated_nonempty_list(COMMA,pat)) -> + +State 11: +## Known stack suffix: +## OPEN_PAREN +## LR(1) items: +patTuple -> OPEN_PAREN . loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 5 +-- On TRUE shift to state 6 +-- On STRING shift to state 7 +-- On QUESTION shift to state 8 +-- On OPEN_SQUARE_BRACKET shift to state 10 +-- On OPEN_PAREN shift to state 11 +-- On INT shift to state 12 +-- On IDENT shift to state 13 +-- On FLOAT shift to state 14 +-- On FALSE shift to state 15 +-- On CONSTRUCTOR_IDENT shift to state 16 +-- On varPat shift to state 40 +-- On separated_nonempty_list(COMMA,pat) shift to state 41 +-- On patTuple shift to state 42 +-- On pat shift to state 43 +-- On loption(separated_nonempty_list(COMMA,pat)) shift to state 51 +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,pat)) -> + +State 12: +## Known stack suffix: +## INT +## LR(1) items: +pat -> INT . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> INT + +State 13: +## Known stack suffix: +## IDENT +## LR(1) items: +varPat -> IDENT . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production varPat -> IDENT + +State 14: +## Known stack suffix: +## FLOAT +## LR(1) items: +pat -> FLOAT . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> FLOAT + +State 15: +## Known stack suffix: +## FALSE +## LR(1) items: +pat -> FALSE . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> FALSE + +State 16: +## Known stack suffix: +## CONSTRUCTOR_IDENT +## LR(1) items: +pat -> CONSTRUCTOR_IDENT . COLON typ [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On COLON shift to state 17 +## Reductions: + +State 17: +## Known stack suffix: +## CONSTRUCTOR_IDENT COLON +## LR(1) items: +pat -> CONSTRUCTOR_IDENT COLON . typ [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 18 +-- On UNIT shift to state 20 +-- On STRING_TYPE shift to state 21 +-- On QUESTION shift to state 22 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On BOOL_TYPE shift to state 28 +-- On typ shift to state 39 +## Reductions: + +State 18: +## Known stack suffix: +## UNKNOWN +## LR(1) items: +typ -> UNKNOWN . INTERNAL [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On INTERNAL shift to state 19 +## Reductions: + +State 19: +## Known stack suffix: +## UNKNOWN INTERNAL +## LR(1) items: +typ -> UNKNOWN INTERNAL . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production typ -> UNKNOWN INTERNAL + +State 20: +## Known stack suffix: +## UNIT +## LR(1) items: +typ -> UNIT . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production typ -> UNIT + +State 21: +## Known stack suffix: +## STRING_TYPE +## LR(1) items: +typ -> STRING_TYPE . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production typ -> STRING_TYPE + +State 22: +## Known stack suffix: +## QUESTION +## LR(1) items: +typ -> QUESTION . STRING [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 23 +## Reductions: + +State 23: +## Known stack suffix: +## QUESTION STRING +## LR(1) items: +typ -> QUESTION STRING . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production typ -> QUESTION STRING + +State 24: +## Known stack suffix: +## OPEN_SQUARE_BRACKET +## LR(1) items: +typ -> OPEN_SQUARE_BRACKET . typ CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 18 +-- On UNIT shift to state 20 +-- On STRING_TYPE shift to state 21 +-- On QUESTION shift to state 22 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On BOOL_TYPE shift to state 28 +-- On typ shift to state 37 +## Reductions: + +State 25: +## Known stack suffix: +## OPEN_PAREN +## LR(1) items: +typ -> OPEN_PAREN . loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 18 +-- On UNIT shift to state 20 +-- On STRING_TYPE shift to state 21 +-- On QUESTION shift to state 22 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On BOOL_TYPE shift to state 28 +-- On typ shift to state 29 +-- On separated_nonempty_list(COMMA,typ) shift to state 34 +-- On loption(separated_nonempty_list(COMMA,typ)) shift to state 35 +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,typ)) -> + +State 26: +## Known stack suffix: +## INT_TYPE +## LR(1) items: +typ -> INT_TYPE . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production typ -> INT_TYPE + +State 27: +## Known stack suffix: +## FLOAT_TYPE +## LR(1) items: +typ -> FLOAT_TYPE . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production typ -> FLOAT_TYPE + +State 28: +## Known stack suffix: +## BOOL_TYPE +## LR(1) items: +typ -> BOOL_TYPE . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production typ -> BOOL_TYPE + +State 29: +## Known stack suffix: +## typ +## LR(1) items: +separated_nonempty_list(COMMA,typ) -> typ . [ CLOSE_PAREN ] +separated_nonempty_list(COMMA,typ) -> typ . COMMA separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ DASH_ARROW COMMA CLOSE_PAREN ] +## Transitions: +-- On DASH_ARROW shift to state 30 +-- On COMMA shift to state 32 +## Reductions: +-- On CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,typ) -> typ + +State 30: +## Known stack suffix: +## typ DASH_ARROW +## LR(1) items: +typ -> typ DASH_ARROW . typ [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 18 +-- On UNIT shift to state 20 +-- On STRING_TYPE shift to state 21 +-- On QUESTION shift to state 22 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On BOOL_TYPE shift to state 28 +-- On typ shift to state 31 +## Reductions: + +State 31: +## Known stack suffix: +## typ DASH_ARROW typ +## LR(1) items: +typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ DASH_ARROW typ . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production typ -> typ DASH_ARROW typ + +State 32: +## Known stack suffix: +## typ COMMA +## LR(1) items: +separated_nonempty_list(COMMA,typ) -> typ COMMA . separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 18 +-- On UNIT shift to state 20 +-- On STRING_TYPE shift to state 21 +-- On QUESTION shift to state 22 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On BOOL_TYPE shift to state 28 +-- On typ shift to state 29 +-- On separated_nonempty_list(COMMA,typ) shift to state 33 +## Reductions: + +State 33: +## Known stack suffix: +## typ COMMA separated_nonempty_list(COMMA,typ) +## LR(1) items: +separated_nonempty_list(COMMA,typ) -> typ COMMA separated_nonempty_list(COMMA,typ) . [ CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,typ) -> typ COMMA separated_nonempty_list(COMMA,typ) + +State 34: +## Known stack suffix: +## separated_nonempty_list(COMMA,typ) +## LR(1) items: +loption(separated_nonempty_list(COMMA,typ)) -> separated_nonempty_list(COMMA,typ) . [ CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,typ)) -> separated_nonempty_list(COMMA,typ) + +State 35: +## Known stack suffix: +## OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) +## LR(1) items: +typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) . CLOSE_PAREN [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On CLOSE_PAREN shift to state 36 +## Reductions: + +State 36: +## Known stack suffix: +## OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN +## LR(1) items: +typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN + +State 37: +## Known stack suffix: +## OPEN_SQUARE_BRACKET typ +## LR(1) items: +typ -> OPEN_SQUARE_BRACKET typ . CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ DASH_ARROW CLOSE_SQUARE_BRACKET ] +## Transitions: +-- On DASH_ARROW shift to state 30 +-- On CLOSE_SQUARE_BRACKET shift to state 38 +## Reductions: + +State 38: +## Known stack suffix: +## OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET +## LR(1) items: +typ -> OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production typ -> OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET + +State 39: +## Known stack suffix: +## CONSTRUCTOR_IDENT COLON typ +## LR(1) items: +pat -> CONSTRUCTOR_IDENT COLON typ . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On DASH_ARROW shift to state 30 +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> CONSTRUCTOR_IDENT COLON typ + +State 40: +## Known stack suffix: +## varPat +## LR(1) items: +pat -> varPat . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> varPat + +State 41: +## Known stack suffix: +## separated_nonempty_list(COMMA,pat) +## LR(1) items: +loption(separated_nonempty_list(COMMA,pat)) -> separated_nonempty_list(COMMA,pat) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,pat)) -> separated_nonempty_list(COMMA,pat) + +State 42: +## Known stack suffix: +## patTuple +## LR(1) items: +pat -> patTuple . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> patTuple + +State 43: +## Known stack suffix: +## pat +## LR(1) items: +pat -> pat . CONS pat [ OPEN_PAREN CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +separated_nonempty_list(COMMA,pat) -> pat . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +separated_nonempty_list(COMMA,pat) -> pat . COMMA separated_nonempty_list(COMMA,pat) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On OPEN_PAREN shift to state 44 +-- On CONS shift to state 46 +-- On COMMA shift to state 49 +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,pat) -> pat + +State 44: +## Known stack suffix: +## pat OPEN_PAREN +## LR(1) items: +pat -> pat OPEN_PAREN . pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 5 +-- On TRUE shift to state 6 +-- On STRING shift to state 7 +-- On QUESTION shift to state 8 +-- On OPEN_SQUARE_BRACKET shift to state 10 +-- On OPEN_PAREN shift to state 11 +-- On INT shift to state 12 +-- On IDENT shift to state 13 +-- On FLOAT shift to state 14 +-- On FALSE shift to state 15 +-- On CONSTRUCTOR_IDENT shift to state 16 +-- On varPat shift to state 40 +-- On patTuple shift to state 42 +-- On pat shift to state 45 +## Reductions: + +State 45: +## Known stack suffix: +## pat OPEN_PAREN pat +## LR(1) items: +pat -> pat . CONS pat [ OPEN_PAREN CONS CLOSE_PAREN ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN CONS CLOSE_PAREN ] +pat -> pat OPEN_PAREN pat . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On OPEN_PAREN shift to state 44 +-- On CONS shift to state 46 +-- On CLOSE_PAREN shift to state 48 +## Reductions: + +State 46: +## Known stack suffix: +## pat CONS +## LR(1) items: +pat -> pat CONS . pat [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 5 +-- On TRUE shift to state 6 +-- On STRING shift to state 7 +-- On QUESTION shift to state 8 +-- On OPEN_SQUARE_BRACKET shift to state 10 +-- On OPEN_PAREN shift to state 11 +-- On INT shift to state 12 +-- On IDENT shift to state 13 +-- On FLOAT shift to state 14 +-- On FALSE shift to state 15 +-- On CONSTRUCTOR_IDENT shift to state 16 +-- On varPat shift to state 40 +-- On patTuple shift to state 42 +-- On pat shift to state 47 +## Reductions: + +State 47: +## Known stack suffix: +## pat CONS pat +## LR(1) items: +pat -> pat . CONS pat [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat CONS pat . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On OPEN_PAREN shift to state 44 +## Reductions: +-- On SINGLE_EQUAL EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> pat CONS pat + +State 48: +## Known stack suffix: +## pat OPEN_PAREN pat CLOSE_PAREN +## LR(1) items: +pat -> pat OPEN_PAREN pat CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> pat OPEN_PAREN pat CLOSE_PAREN + +State 49: +## Known stack suffix: +## pat COMMA +## LR(1) items: +separated_nonempty_list(COMMA,pat) -> pat COMMA . separated_nonempty_list(COMMA,pat) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 5 +-- On TRUE shift to state 6 +-- On STRING shift to state 7 +-- On QUESTION shift to state 8 +-- On OPEN_SQUARE_BRACKET shift to state 10 +-- On OPEN_PAREN shift to state 11 +-- On INT shift to state 12 +-- On IDENT shift to state 13 +-- On FLOAT shift to state 14 +-- On FALSE shift to state 15 +-- On CONSTRUCTOR_IDENT shift to state 16 +-- On varPat shift to state 40 +-- On separated_nonempty_list(COMMA,pat) shift to state 50 +-- On patTuple shift to state 42 +-- On pat shift to state 43 +## Reductions: + +State 50: +## Known stack suffix: +## pat COMMA separated_nonempty_list(COMMA,pat) +## LR(1) items: +separated_nonempty_list(COMMA,pat) -> pat COMMA separated_nonempty_list(COMMA,pat) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,pat) -> pat COMMA separated_nonempty_list(COMMA,pat) + +State 51: +## Known stack suffix: +## OPEN_PAREN loption(separated_nonempty_list(COMMA,pat)) +## LR(1) items: +patTuple -> OPEN_PAREN loption(separated_nonempty_list(COMMA,pat)) . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On CLOSE_PAREN shift to state 52 +## Reductions: + +State 52: +## Known stack suffix: +## OPEN_PAREN loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN +## LR(1) items: +patTuple -> OPEN_PAREN loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production patTuple -> OPEN_PAREN loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN + +State 53: +## Known stack suffix: +## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) +## LR(1) items: +pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) . CLOSE_SQUARE_BRACKET [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On CLOSE_SQUARE_BRACKET shift to state 54 +## Reductions: + +State 54: +## Known stack suffix: +## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET +## LR(1) items: +pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET + +State 55: +## Known stack suffix: +## LET pat +## LR(1) items: +exp -> LET pat . SINGLE_EQUAL exp IN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . CONS pat [ SINGLE_EQUAL OPEN_PAREN CONS ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN CONS ] +## Transitions: +-- On SINGLE_EQUAL shift to state 56 +-- On OPEN_PAREN shift to state 44 +-- On CONS shift to state 46 +## Reductions: + +State 56: +## Known stack suffix: +## LET pat SINGLE_EQUAL +## LR(1) items: +exp -> LET pat SINGLE_EQUAL . exp IN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 113 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 57: +## Known stack suffix: +## INT +## LR(1) items: +exp -> INT . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> INT + +State 58: +## Known stack suffix: +## IF +## LR(1) items: +exp -> IF . exp THEN exp ELSE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 108 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 59: +## Known stack suffix: +## IDENT +## LR(1) items: +exp -> IDENT . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> IDENT + +State 60: +## Known stack suffix: +## FLOAT +## LR(1) items: +exp -> FLOAT . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> FLOAT + +State 61: +## Known stack suffix: +## CONSTRUCTOR_IDENT +## LR(1) items: +exp -> CONSTRUCTOR_IDENT . COLON typ [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On COLON shift to state 62 +## Reductions: + +State 62: +## Known stack suffix: +## CONSTRUCTOR_IDENT COLON +## LR(1) items: +exp -> CONSTRUCTOR_IDENT COLON . typ [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 18 +-- On UNIT shift to state 20 +-- On STRING_TYPE shift to state 21 +-- On QUESTION shift to state 22 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On BOOL_TYPE shift to state 28 +-- On typ shift to state 63 +## Reductions: + +State 63: +## Known stack suffix: +## CONSTRUCTOR_IDENT COLON typ +## LR(1) items: +exp -> CONSTRUCTOR_IDENT COLON typ . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On DASH_ARROW shift to state 30 +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> CONSTRUCTOR_IDENT COLON typ + +State 64: +## Known stack suffix: +## CASE +## LR(1) items: +case -> CASE . exp list(rul) END [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 65 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 65: +## Known stack suffix: +## CASE exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . POWER exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +case -> CASE exp . list(rul) END [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +## Transitions: +-- On TURNSTILE shift to state 66 +-- On TIMES shift to state 70 +-- On QUESTION shift to state 72 +-- On POWER shift to state 81 +-- On PLUS shift to state 85 +-- On OPEN_PAREN shift to state 78 +-- On NOT_EQUAL shift to state 87 +-- On MINUS shift to state 89 +-- On LESS_THAN_EQUAL shift to state 91 +-- On GREATER_THAN_EQUAL shift to state 93 +-- On GREATER_THAN shift to state 95 +-- On DOUBLE_EQUAL shift to state 97 +-- On DIVIDE shift to state 99 +-- On rul shift to state 104 +-- On list(rul) shift to state 106 +## Reductions: +-- On END +-- reduce production list(rul) -> + +State 66: +## Known stack suffix: +## TURNSTILE +## LR(1) items: +rul -> TURNSTILE . pat EQUAL_ARROW exp [ TURNSTILE END ] +## Transitions: +-- On WILD shift to state 5 +-- On TRUE shift to state 6 +-- On STRING shift to state 7 +-- On QUESTION shift to state 8 +-- On OPEN_SQUARE_BRACKET shift to state 10 +-- On OPEN_PAREN shift to state 11 +-- On INT shift to state 12 +-- On IDENT shift to state 13 +-- On FLOAT shift to state 14 +-- On FALSE shift to state 15 +-- On CONSTRUCTOR_IDENT shift to state 16 +-- On varPat shift to state 40 +-- On patTuple shift to state 42 +-- On pat shift to state 67 +## Reductions: + +State 67: +## Known stack suffix: +## TURNSTILE pat +## LR(1) items: +pat -> pat . CONS pat [ OPEN_PAREN EQUAL_ARROW CONS ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN EQUAL_ARROW CONS ] +rul -> TURNSTILE pat . EQUAL_ARROW exp [ TURNSTILE END ] +## Transitions: +-- On OPEN_PAREN shift to state 44 +-- On EQUAL_ARROW shift to state 68 +-- On CONS shift to state 46 +## Reductions: + +State 68: +## Known stack suffix: +## TURNSTILE pat EQUAL_ARROW +## LR(1) items: +rul -> TURNSTILE pat EQUAL_ARROW . exp [ TURNSTILE END ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 69 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 69: +## Known stack suffix: +## TURNSTILE pat EQUAL_ARROW exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . POWER exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] +rul -> TURNSTILE pat EQUAL_ARROW exp . [ TURNSTILE END ] +## Transitions: +-- On TIMES shift to state 70 +-- On QUESTION shift to state 72 +-- On POWER shift to state 81 +-- On PLUS shift to state 85 +-- On OPEN_PAREN shift to state 78 +-- On NOT_EQUAL shift to state 87 +-- On MINUS shift to state 89 +-- On LESS_THAN_EQUAL shift to state 91 +-- On GREATER_THAN_EQUAL shift to state 93 +-- On GREATER_THAN shift to state 95 +-- On DOUBLE_EQUAL shift to state 97 +-- On DIVIDE shift to state 99 +## Reductions: +-- On TURNSTILE END +-- reduce production rul -> TURNSTILE pat EQUAL_ARROW exp + +State 70: +## Known stack suffix: +## exp TIMES +## LR(1) items: +binExp -> exp TIMES . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 71 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 71: +## Known stack suffix: +## exp TIMES exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp TIMES exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On QUESTION shift to state 72 +-- On OPEN_PAREN shift to state 78 +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp TIMES exp +** Conflict on QUESTION + +State 72: +## Known stack suffix: +## exp QUESTION +## LR(1) items: +exp -> exp QUESTION . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On LESS_THAN shift to state 73 +## Reductions: + +State 73: +## Known stack suffix: +## exp QUESTION LESS_THAN +## LR(1) items: +exp -> exp QUESTION LESS_THAN . typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 18 +-- On UNIT shift to state 20 +-- On STRING_TYPE shift to state 21 +-- On QUESTION shift to state 22 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On BOOL_TYPE shift to state 28 +-- On typ shift to state 74 +## Reductions: + +State 74: +## Known stack suffix: +## exp QUESTION LESS_THAN typ +## LR(1) items: +exp -> exp QUESTION LESS_THAN typ . EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] +## Transitions: +-- On EQUAL_ARROW shift to state 75 +-- On DASH_ARROW shift to state 30 +## Reductions: + +State 75: +## Known stack suffix: +## exp QUESTION LESS_THAN typ EQUAL_ARROW +## LR(1) items: +exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW . typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 18 +-- On UNIT shift to state 20 +-- On STRING_TYPE shift to state 21 +-- On QUESTION shift to state 22 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On BOOL_TYPE shift to state 28 +-- On typ shift to state 76 +## Reductions: + +State 76: +## Known stack suffix: +## exp QUESTION LESS_THAN typ EQUAL_ARROW typ +## LR(1) items: +exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW typ . GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ GREATER_THAN DASH_ARROW ] +## Transitions: +-- On GREATER_THAN shift to state 77 +-- On DASH_ARROW shift to state 30 +## Reductions: + +State 77: +## Known stack suffix: +## exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN +## LR(1) items: +exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +State 78: +## Known stack suffix: +## exp OPEN_PAREN +## LR(1) items: +exp -> exp OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp OPEN_PAREN . WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 79 +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 102 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 79: +## Known stack suffix: +## exp OPEN_PAREN WILD +## LR(1) items: +exp -> exp OPEN_PAREN WILD . exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 80 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 80: +## Known stack suffix: +## exp OPEN_PAREN WILD exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +exp -> exp OPEN_PAREN WILD exp . CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +## Transitions: +-- On TIMES shift to state 70 +-- On QUESTION shift to state 72 +-- On POWER shift to state 81 +-- On PLUS shift to state 85 +-- On OPEN_PAREN shift to state 78 +-- On NOT_EQUAL shift to state 87 +-- On MINUS shift to state 89 +-- On LESS_THAN_EQUAL shift to state 91 +-- On GREATER_THAN_EQUAL shift to state 93 +-- On GREATER_THAN shift to state 95 +-- On DOUBLE_EQUAL shift to state 97 +-- On DIVIDE shift to state 99 +-- On CLOSE_PAREN shift to state 101 +## Reductions: + +State 81: +## Known stack suffix: +## exp POWER +## LR(1) items: +binExp -> exp POWER . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 82 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 82: +## Known stack suffix: +## exp POWER exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp POWER exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On QUESTION shift to state 72 +-- On OPEN_PAREN shift to state 78 +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp POWER exp +** Conflict on QUESTION + +State 83: +## Known stack suffix: +## case +## LR(1) items: +exp -> case . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> case + +State 84: +## Known stack suffix: +## binExp +## LR(1) items: +exp -> binExp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> binExp + +State 85: +## Known stack suffix: +## exp PLUS +## LR(1) items: +binExp -> exp PLUS . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 86 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 86: +## Known stack suffix: +## exp PLUS exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp PLUS exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On QUESTION shift to state 72 +-- On OPEN_PAREN shift to state 78 +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp PLUS exp +** Conflict on QUESTION + +State 87: +## Known stack suffix: +## exp NOT_EQUAL +## LR(1) items: +binExp -> exp NOT_EQUAL . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 88 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 88: +## Known stack suffix: +## exp NOT_EQUAL exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp NOT_EQUAL exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On QUESTION shift to state 72 +-- On OPEN_PAREN shift to state 78 +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp NOT_EQUAL exp +** Conflict on QUESTION + +State 89: +## Known stack suffix: +## exp MINUS +## LR(1) items: +binExp -> exp MINUS . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 90 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 90: +## Known stack suffix: +## exp MINUS exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp MINUS exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On QUESTION shift to state 72 +-- On OPEN_PAREN shift to state 78 +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp MINUS exp +** Conflict on QUESTION + +State 91: +## Known stack suffix: +## exp LESS_THAN_EQUAL +## LR(1) items: +binExp -> exp LESS_THAN_EQUAL . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 92 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 92: +## Known stack suffix: +## exp LESS_THAN_EQUAL exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp LESS_THAN_EQUAL exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On QUESTION shift to state 72 +-- On OPEN_PAREN shift to state 78 +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp LESS_THAN_EQUAL exp +** Conflict on QUESTION + +State 93: +## Known stack suffix: +## exp GREATER_THAN_EQUAL +## LR(1) items: +binExp -> exp GREATER_THAN_EQUAL . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 94 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 94: +## Known stack suffix: +## exp GREATER_THAN_EQUAL exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp GREATER_THAN_EQUAL exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On QUESTION shift to state 72 +-- On OPEN_PAREN shift to state 78 +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp GREATER_THAN_EQUAL exp +** Conflict on QUESTION + +State 95: +## Known stack suffix: +## exp GREATER_THAN +## LR(1) items: +binExp -> exp GREATER_THAN . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 96 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 96: +## Known stack suffix: +## exp GREATER_THAN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp GREATER_THAN exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On QUESTION shift to state 72 +-- On OPEN_PAREN shift to state 78 +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp GREATER_THAN exp +** Conflict on QUESTION + +State 97: +## Known stack suffix: +## exp DOUBLE_EQUAL +## LR(1) items: +binExp -> exp DOUBLE_EQUAL . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 98 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 98: +## Known stack suffix: +## exp DOUBLE_EQUAL exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp DOUBLE_EQUAL exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On QUESTION shift to state 72 +-- On OPEN_PAREN shift to state 78 +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp DOUBLE_EQUAL exp +** Conflict on QUESTION + +State 99: +## Known stack suffix: +## exp DIVIDE +## LR(1) items: +binExp -> exp DIVIDE . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 100 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 100: +## Known stack suffix: +## exp DIVIDE exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp DIVIDE exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On QUESTION shift to state 72 +-- On OPEN_PAREN shift to state 78 +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp DIVIDE exp +** Conflict on QUESTION + +State 101: +## Known stack suffix: +## exp OPEN_PAREN WILD exp CLOSE_PAREN +## LR(1) items: +exp -> exp OPEN_PAREN WILD exp CLOSE_PAREN . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> exp OPEN_PAREN WILD exp CLOSE_PAREN + +State 102: +## Known stack suffix: +## exp OPEN_PAREN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +exp -> exp OPEN_PAREN exp . CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] +## Transitions: +-- On TIMES shift to state 70 +-- On QUESTION shift to state 72 +-- On POWER shift to state 81 +-- On PLUS shift to state 85 +-- On OPEN_PAREN shift to state 78 +-- On NOT_EQUAL shift to state 87 +-- On MINUS shift to state 89 +-- On LESS_THAN_EQUAL shift to state 91 +-- On GREATER_THAN_EQUAL shift to state 93 +-- On GREATER_THAN shift to state 95 +-- On DOUBLE_EQUAL shift to state 97 +-- On DIVIDE shift to state 99 +-- On CLOSE_PAREN shift to state 103 +## Reductions: + +State 103: +## Known stack suffix: +## exp OPEN_PAREN exp CLOSE_PAREN +## LR(1) items: +exp -> exp OPEN_PAREN exp CLOSE_PAREN . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> exp OPEN_PAREN exp CLOSE_PAREN + +State 104: +## Known stack suffix: +## rul +## LR(1) items: +list(rul) -> rul . list(rul) [ END ] +## Transitions: +-- On TURNSTILE shift to state 66 +-- On rul shift to state 104 +-- On list(rul) shift to state 105 +## Reductions: +-- On END +-- reduce production list(rul) -> + +State 105: +## Known stack suffix: +## rul list(rul) +## LR(1) items: +list(rul) -> rul list(rul) . [ END ] +## Transitions: +## Reductions: +-- On END +-- reduce production list(rul) -> rul list(rul) + +State 106: +## Known stack suffix: +## CASE exp list(rul) +## LR(1) items: +case -> CASE exp list(rul) . END [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On END shift to state 107 +## Reductions: + +State 107: +## Known stack suffix: +## CASE exp list(rul) END +## LR(1) items: +case -> CASE exp list(rul) END . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production case -> CASE exp list(rul) END + +State 108: +## Known stack suffix: +## IF exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . MINUS exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . TIMES exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . POWER exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . DIVIDE exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . NOT_EQUAL exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . GREATER_THAN exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +exp -> IF exp . THEN exp ELSE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +## Transitions: +-- On TIMES shift to state 70 +-- On THEN shift to state 109 +-- On QUESTION shift to state 72 +-- On POWER shift to state 81 +-- On PLUS shift to state 85 +-- On OPEN_PAREN shift to state 78 +-- On NOT_EQUAL shift to state 87 +-- On MINUS shift to state 89 +-- On LESS_THAN_EQUAL shift to state 91 +-- On GREATER_THAN_EQUAL shift to state 93 +-- On GREATER_THAN shift to state 95 +-- On DOUBLE_EQUAL shift to state 97 +-- On DIVIDE shift to state 99 +## Reductions: + +State 109: +## Known stack suffix: +## IF exp THEN +## LR(1) items: +exp -> IF exp THEN . exp ELSE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 110 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 110: +## Known stack suffix: +## IF exp THEN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +exp -> IF exp THEN exp . ELSE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] +## Transitions: +-- On TIMES shift to state 70 +-- On QUESTION shift to state 72 +-- On POWER shift to state 81 +-- On PLUS shift to state 85 +-- On OPEN_PAREN shift to state 78 +-- On NOT_EQUAL shift to state 87 +-- On MINUS shift to state 89 +-- On LESS_THAN_EQUAL shift to state 91 +-- On GREATER_THAN_EQUAL shift to state 93 +-- On GREATER_THAN shift to state 95 +-- On ELSE shift to state 111 +-- On DOUBLE_EQUAL shift to state 97 +-- On DIVIDE shift to state 99 +## Reductions: + +State 111: +## Known stack suffix: +## IF exp THEN exp ELSE +## LR(1) items: +exp -> IF exp THEN exp ELSE . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 112 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 112: +## Known stack suffix: +## IF exp THEN exp ELSE exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> IF exp THEN exp ELSE exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On TIMES shift to state 70 +-- On QUESTION shift to state 72 +-- On POWER shift to state 81 +-- On PLUS shift to state 85 +-- On OPEN_PAREN shift to state 78 +-- On NOT_EQUAL shift to state 87 +-- On MINUS shift to state 89 +-- On LESS_THAN_EQUAL shift to state 91 +-- On GREATER_THAN_EQUAL shift to state 93 +-- On GREATER_THAN shift to state 95 +-- On DOUBLE_EQUAL shift to state 97 +-- On DIVIDE shift to state 99 +## Reductions: +-- On TURNSTILE THEN QUESTION IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> IF exp THEN exp ELSE exp +** Conflict on QUESTION + +State 113: +## Known stack suffix: +## LET pat SINGLE_EQUAL exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +exp -> LET pat SINGLE_EQUAL exp . IN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] +## Transitions: +-- On TIMES shift to state 70 +-- On QUESTION shift to state 72 +-- On POWER shift to state 81 +-- On PLUS shift to state 85 +-- On OPEN_PAREN shift to state 78 +-- On NOT_EQUAL shift to state 87 +-- On MINUS shift to state 89 +-- On LESS_THAN_EQUAL shift to state 91 +-- On IN shift to state 114 +-- On GREATER_THAN_EQUAL shift to state 93 +-- On GREATER_THAN shift to state 95 +-- On DOUBLE_EQUAL shift to state 97 +-- On DIVIDE shift to state 99 +## Reductions: + +State 114: +## Known stack suffix: +## LET pat SINGLE_EQUAL exp IN +## LR(1) items: +exp -> LET pat SINGLE_EQUAL exp IN . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On exp shift to state 115 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 115: +## Known stack suffix: +## LET pat SINGLE_EQUAL exp IN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> LET pat SINGLE_EQUAL exp IN exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On TIMES shift to state 70 +-- On QUESTION shift to state 72 +-- On POWER shift to state 81 +-- On PLUS shift to state 85 +-- On OPEN_PAREN shift to state 78 +-- On NOT_EQUAL shift to state 87 +-- On MINUS shift to state 89 +-- On LESS_THAN_EQUAL shift to state 91 +-- On GREATER_THAN_EQUAL shift to state 93 +-- On GREATER_THAN shift to state 95 +-- On DOUBLE_EQUAL shift to state 97 +-- On DIVIDE shift to state 99 +## Reductions: +-- On TURNSTILE THEN QUESTION IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> LET pat SINGLE_EQUAL exp IN exp +** Conflict on QUESTION + +State 116: +## Known stack suffix: +## OPEN_PAREN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +exp -> OPEN_PAREN exp . CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> OPEN_PAREN exp . COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] +## Transitions: +-- On TIMES shift to state 70 +-- On QUESTION shift to state 72 +-- On POWER shift to state 81 +-- On PLUS shift to state 85 +-- On OPEN_PAREN shift to state 78 +-- On NOT_EQUAL shift to state 87 +-- On MINUS shift to state 89 +-- On LESS_THAN_EQUAL shift to state 91 +-- On GREATER_THAN_EQUAL shift to state 93 +-- On GREATER_THAN shift to state 95 +-- On DOUBLE_EQUAL shift to state 97 +-- On DIVIDE shift to state 99 +-- On COMMA shift to state 117 +-- On CLOSE_PAREN shift to state 124 +## Reductions: + +State 117: +## Known stack suffix: +## OPEN_PAREN exp COMMA +## LR(1) items: +exp -> OPEN_PAREN exp COMMA . loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On separated_nonempty_list(COMMA,exp) shift to state 118 +-- On loption(separated_nonempty_list(COMMA,exp)) shift to state 119 +-- On exp shift to state 121 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,exp)) -> + +State 118: +## Known stack suffix: +## separated_nonempty_list(COMMA,exp) +## LR(1) items: +loption(separated_nonempty_list(COMMA,exp)) -> separated_nonempty_list(COMMA,exp) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,exp)) -> separated_nonempty_list(COMMA,exp) + +State 119: +## Known stack suffix: +## OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) +## LR(1) items: +exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) . CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On CLOSE_PAREN shift to state 120 +## Reductions: + +State 120: +## Known stack suffix: +## OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN +## LR(1) items: +exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN + +State 121: +## Known stack suffix: +## exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +separated_nonempty_list(COMMA,exp) -> exp . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +separated_nonempty_list(COMMA,exp) -> exp . COMMA separated_nonempty_list(COMMA,exp) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On TIMES shift to state 70 +-- On QUESTION shift to state 72 +-- On POWER shift to state 81 +-- On PLUS shift to state 85 +-- On OPEN_PAREN shift to state 78 +-- On NOT_EQUAL shift to state 87 +-- On MINUS shift to state 89 +-- On LESS_THAN_EQUAL shift to state 91 +-- On GREATER_THAN_EQUAL shift to state 93 +-- On GREATER_THAN shift to state 95 +-- On DOUBLE_EQUAL shift to state 97 +-- On DIVIDE shift to state 99 +-- On COMMA shift to state 122 +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,exp) -> exp + +State 122: +## Known stack suffix: +## exp COMMA +## LR(1) items: +separated_nonempty_list(COMMA,exp) -> exp COMMA . separated_nonempty_list(COMMA,exp) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 1 +-- On OPEN_SQUARE_BRACKET shift to state 2 +-- On OPEN_PAREN shift to state 3 +-- On LET shift to state 4 +-- On INT shift to state 57 +-- On IF shift to state 58 +-- On IDENT shift to state 59 +-- On FLOAT shift to state 60 +-- On CONSTRUCTOR_IDENT shift to state 61 +-- On CASE shift to state 64 +-- On separated_nonempty_list(COMMA,exp) shift to state 123 +-- On exp shift to state 121 +-- On case shift to state 83 +-- On binExp shift to state 84 +## Reductions: + +State 123: +## Known stack suffix: +## exp COMMA separated_nonempty_list(COMMA,exp) +## LR(1) items: +separated_nonempty_list(COMMA,exp) -> exp COMMA separated_nonempty_list(COMMA,exp) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,exp) -> exp COMMA separated_nonempty_list(COMMA,exp) + +State 124: +## Known stack suffix: +## OPEN_PAREN exp CLOSE_PAREN +## LR(1) items: +exp -> OPEN_PAREN exp CLOSE_PAREN . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> OPEN_PAREN exp CLOSE_PAREN + +State 125: +## Known stack suffix: +## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) +## LR(1) items: +exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) . CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On CLOSE_SQUARE_BRACKET shift to state 126 +## Reductions: + +State 126: +## Known stack suffix: +## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET +## LR(1) items: +exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET + +State 127: +## Known stack suffix: +## program +## LR(1) items: +program' -> program . [ # ] +## Transitions: +## Reductions: +-- On # +-- accept program + +State 128: +## Known stack suffix: +## exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] +program -> exp . EOF [ # ] +## Transitions: +-- On TIMES shift to state 70 +-- On QUESTION shift to state 72 +-- On POWER shift to state 81 +-- On PLUS shift to state 85 +-- On OPEN_PAREN shift to state 78 +-- On NOT_EQUAL shift to state 87 +-- On MINUS shift to state 89 +-- On LESS_THAN_EQUAL shift to state 91 +-- On GREATER_THAN_EQUAL shift to state 93 +-- On GREATER_THAN shift to state 95 +-- On EOF shift to state 129 +-- On DOUBLE_EQUAL shift to state 97 +-- On DIVIDE shift to state 99 +## Reductions: + +State 129: +## Known stack suffix: +## exp EOF +## LR(1) items: +program -> exp EOF . [ # ] +## Transitions: +## Reductions: +-- On # +-- reduce production program -> exp EOF + diff --git a/src/haz3lmenhir/Parser.conflicts b/src/haz3lmenhir/Parser.conflicts new file mode 100644 index 0000000000..12b9fc39ae --- /dev/null +++ b/src/haz3lmenhir/Parser.conflicts @@ -0,0 +1,332 @@ + +** Conflict (shift/reduce) in state 115. +** Token involved: QUESTION +** This state is reached from program after reading: + +LET pat SINGLE_EQUAL exp IN exp + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 115, looking ahead at QUESTION, reducing production +** exp -> LET pat SINGLE_EQUAL exp IN exp +** is permitted because of the following sub-derivation: + +exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears +LET pat SINGLE_EQUAL exp IN exp . + +** In state 115, looking ahead at QUESTION, shifting is permitted +** because of the following sub-derivation: + +LET pat SINGLE_EQUAL exp IN exp + exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +** Conflict (shift/reduce) in state 112. +** Token involved: QUESTION +** This state is reached from program after reading: + +IF exp THEN exp ELSE exp + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 112, looking ahead at QUESTION, reducing production +** exp -> IF exp THEN exp ELSE exp +** is permitted because of the following sub-derivation: + +exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears +IF exp THEN exp ELSE exp . + +** In state 112, looking ahead at QUESTION, shifting is permitted +** because of the following sub-derivation: + +IF exp THEN exp ELSE exp + exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +** Conflict (shift/reduce) in state 100. +** Token involved: QUESTION +** This state is reached from program after reading: + +exp DIVIDE exp + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 100, looking ahead at QUESTION, reducing production +** binExp -> exp DIVIDE exp +** is permitted because of the following sub-derivation: + +exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears +binExp // lookahead token is inherited +exp DIVIDE exp . + +** In state 100, looking ahead at QUESTION, shifting is permitted +** because of the following sub-derivation: + +binExp +exp DIVIDE exp + exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +** Conflict (shift/reduce) in state 98. +** Token involved: QUESTION +** This state is reached from program after reading: + +exp DOUBLE_EQUAL exp + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 98, looking ahead at QUESTION, reducing production +** binExp -> exp DOUBLE_EQUAL exp +** is permitted because of the following sub-derivation: + +exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears +binExp // lookahead token is inherited +exp DOUBLE_EQUAL exp . + +** In state 98, looking ahead at QUESTION, shifting is permitted +** because of the following sub-derivation: + +binExp +exp DOUBLE_EQUAL exp + exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +** Conflict (shift/reduce) in state 96. +** Token involved: QUESTION +** This state is reached from program after reading: + +exp GREATER_THAN exp + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 96, looking ahead at QUESTION, reducing production +** binExp -> exp GREATER_THAN exp +** is permitted because of the following sub-derivation: + +exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears +binExp // lookahead token is inherited +exp GREATER_THAN exp . + +** In state 96, looking ahead at QUESTION, shifting is permitted +** because of the following sub-derivation: + +binExp +exp GREATER_THAN exp + exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +** Conflict (shift/reduce) in state 94. +** Token involved: QUESTION +** This state is reached from program after reading: + +exp GREATER_THAN_EQUAL exp + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 94, looking ahead at QUESTION, reducing production +** binExp -> exp GREATER_THAN_EQUAL exp +** is permitted because of the following sub-derivation: + +exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears +binExp // lookahead token is inherited +exp GREATER_THAN_EQUAL exp . + +** In state 94, looking ahead at QUESTION, shifting is permitted +** because of the following sub-derivation: + +binExp +exp GREATER_THAN_EQUAL exp + exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +** Conflict (shift/reduce) in state 92. +** Token involved: QUESTION +** This state is reached from program after reading: + +exp LESS_THAN_EQUAL exp + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 92, looking ahead at QUESTION, reducing production +** binExp -> exp LESS_THAN_EQUAL exp +** is permitted because of the following sub-derivation: + +exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears +binExp // lookahead token is inherited +exp LESS_THAN_EQUAL exp . + +** In state 92, looking ahead at QUESTION, shifting is permitted +** because of the following sub-derivation: + +binExp +exp LESS_THAN_EQUAL exp + exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +** Conflict (shift/reduce) in state 90. +** Token involved: QUESTION +** This state is reached from program after reading: + +exp MINUS exp + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 90, looking ahead at QUESTION, reducing production +** binExp -> exp MINUS exp +** is permitted because of the following sub-derivation: + +exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears +binExp // lookahead token is inherited +exp MINUS exp . + +** In state 90, looking ahead at QUESTION, shifting is permitted +** because of the following sub-derivation: + +binExp +exp MINUS exp + exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +** Conflict (shift/reduce) in state 88. +** Token involved: QUESTION +** This state is reached from program after reading: + +exp NOT_EQUAL exp + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 88, looking ahead at QUESTION, reducing production +** binExp -> exp NOT_EQUAL exp +** is permitted because of the following sub-derivation: + +exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears +binExp // lookahead token is inherited +exp NOT_EQUAL exp . + +** In state 88, looking ahead at QUESTION, shifting is permitted +** because of the following sub-derivation: + +binExp +exp NOT_EQUAL exp + exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +** Conflict (shift/reduce) in state 86. +** Token involved: QUESTION +** This state is reached from program after reading: + +exp PLUS exp + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 86, looking ahead at QUESTION, reducing production +** binExp -> exp PLUS exp +** is permitted because of the following sub-derivation: + +exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears +binExp // lookahead token is inherited +exp PLUS exp . + +** In state 86, looking ahead at QUESTION, shifting is permitted +** because of the following sub-derivation: + +binExp +exp PLUS exp + exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +** Conflict (shift/reduce) in state 82. +** Token involved: QUESTION +** This state is reached from program after reading: + +exp POWER exp + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 82, looking ahead at QUESTION, reducing production +** binExp -> exp POWER exp +** is permitted because of the following sub-derivation: + +exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears +binExp // lookahead token is inherited +exp POWER exp . + +** In state 82, looking ahead at QUESTION, shifting is permitted +** because of the following sub-derivation: + +binExp +exp POWER exp + exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +** Conflict (shift/reduce) in state 71. +** Token involved: QUESTION +** This state is reached from program after reading: + +exp TIMES exp + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 71, looking ahead at QUESTION, reducing production +** binExp -> exp TIMES exp +** is permitted because of the following sub-derivation: + +exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears +binExp // lookahead token is inherited +exp TIMES exp . + +** In state 71, looking ahead at QUESTION, shifting is permitted +** because of the following sub-derivation: + +binExp +exp TIMES exp + exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 16ca41f077..ac5cfb6039 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -4,6 +4,7 @@ open AST + %token UNDEF %token SEXP_STRING %token DOLLAR_SIGN @@ -89,9 +90,21 @@ open AST %token THEN %token ELSE +%token SEMI_COLON -%token SEMI_COLON + +(* Precedences *) + +%nonassoc IF_EXP +%nonassoc LET_EXP + +%left PLUS MINUS TIMES POWER DIVIDE DOUBLE_EQUAL NOT_EQUAL LESS_THAN LESS_THAN_EQUAL GREATER_THAN GREATER_THAN_EQUAL +(* Other *) +%left DASH_ARROW +%left CONS +%left OPEN_PAREN + %type exp @@ -102,7 +115,7 @@ open AST program: | e = exp; EOF {e} -intOp: +%inline intOp: | PLUS { IntOp(Plus) } | MINUS { IntOp(Minus) } | TIMES { IntOp(Times) } @@ -110,13 +123,13 @@ intOp: | DIVIDE { IntOp(Divide) } | DOUBLE_EQUAL { IntOp(Equals) } | NOT_EQUAL { IntOp(NotEquals) } - | LESS_THAN { IntOp(LessThan) } + (* | LESS_THAN { IntOp(LessThan) } *) | LESS_THAN_EQUAL { IntOp(LessThanOrEqual) } | GREATER_THAN { IntOp(GreaterThan) } | GREATER_THAN_EQUAL { IntOp(GreaterThanOrEqual) } -floatOp: +%inline floatOp: | PLUS_FLOAT { FloatOp(Plus) } | MINUS_FLOAT { FloatOp(Minus) } | TIMES_FLOAT { FloatOp(Times) } @@ -129,17 +142,17 @@ floatOp: | GREATER_THAN_FLOAT { FloatOp(GreaterThan) } | GREATER_THAN_EQUAL_FLOAT { FloatOp(GreaterThanOrEqual) } -boolOp: +%inline boolOp: | L_AND { BoolOp(And) } | L_OR { BoolOp(Or) } -binOp: +%inline binOp: | i = intOp { i } | f = floatOp { f } | b = boolOp { b } binExp: - | e1 = exp; b = binOp; e2 = exp { BinExp (e1, b, e2) } + | e1 = exp; b = intOp; e2 = exp { BinExp (e1, b, e2) } typ: | QUESTION; s = STRING { InvalidTyp(s) } @@ -156,7 +169,8 @@ typ: varPat: | i = IDENT { VarPat (i) } -pat: + +pat: | QUESTION; s = STRING { InvalidPat(s) } | WILD { WildPat } | QUESTION { EmptyHolePat } @@ -171,7 +185,7 @@ pat: | TRUE { BoolPat true} | FALSE {BoolPat false} (* | p1 = pat; AS; p2 = pat; { AsPat(p1, p2) } *) - | p1 = pat; CONS; p2 = pat { ConsPat(p1, p2) } + | p1 = pat; CONS; p2 = pat { ConsPat(p1, p2) } | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } @@ -192,8 +206,8 @@ funExp: | FUN; p = pat; DASH_ARROW; e1 = exp; name = IDENT { Fun (p, e1, Some(name)) } -ifExp: - | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (e1, e2, e3) } +%inline ifExp: + | IF; e1 = exp; THEN; e2 = exp; ELSE; e3 = exp { If (e1, e2, e3) } %prec IF_EXP filterAction: | PAUSE { Pause } @@ -211,40 +225,44 @@ unExp: | MINUS; e = exp {UnOp(Int(Minus), e)} | L_NOT; e = exp {UnOp(Bool(Not), e)} + +(* apExp: *) +(* | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } *) + exp: + | b = binExp { b } | i = INT { Int i } | f = FLOAT { Float f } | v = IDENT { Var v } | c = CONSTRUCTOR_IDENT; COLON; t = typ { Constructor(c, t) } | s = STRING { String s} - | b = binExp { b } - | OPEN_PAREN; e = exp; CLOSE_PAREN { e } - | OPEN_PAREN; l = separated_list(COMMA, exp); CLOSE_PAREN { TupleExp(l) } + | OPEN_PAREN; e = exp; CLOSE_PAREN { e } + | OPEN_PAREN; e = exp; COMMA; l = separated_list(COMMA, exp); CLOSE_PAREN { TupleExp(e :: l) } | c = case { c } | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ListExp(e) } - | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } - | WILD; f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { DeferredAp(f, a) } - | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } - | i = ifExp { i} + | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } + | f = exp; OPEN_PAREN; WILD; a = exp; CLOSE_PAREN { DeferredAp(ApExp(f, a)) } + | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } %prec LET_EXP + | i = ifExp { i } | e1 = exp; QUESTION; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN {FailedCast(e1, t1, t2)} - | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } - | TRUE { Bool true } - | f = funExp {f} - | FALSE { Bool false } - | FIX; p = pat; DASH_ARROW; e = exp { FixF(p, e) } - | TYP_FUN; t = tpat; DASH_ARROW; e = exp {TypFun(t, e)} - | QUESTION { EmptyHole } - | a = filterAction; cond = exp; body = exp { Filter(a, cond, body)} - | TEST; e = exp; END { Test(e) } - | e1 = exp; AT_SYMBOL; e2 = exp { ListConcat(e1, e2) } - | e1 = exp; CONS; e2 = exp { Cons(e1, e2) } - | e1 = exp; SEMI_COLON; e2 = exp { Seq(e1, e2) } - | QUESTION; s = STRING; { InvalidExp(s) } - | IN_AP; WILD {Deferral(InAp)} - | OUT_AP; WILD {Deferral(OutsideAp)} - | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} - | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} - | LESS_THAN; LESS_THAN; e = exp; QUESTION; s = SEXP_STRING; GREATER_THAN; GREATER_THAN {DynamicErrorHole(e, s)} - | b = BUILTIN; {BuiltinFun(b)} - | UNDEF; {Undefined} - | u = unExp { u } + (* | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } *) + (* | TRUE { Bool true } *) + (* | f = funExp {f} *) + (* | FALSE { Bool false } *) + (* | FIX; p = pat; DASH_ARROW; e = exp { FixF(p, e) } *) + (* | TYP_FUN; t = tpat; DASH_ARROW; e = exp {TypFun(t, e)} *) + (* | QUESTION { EmptyHole } *) + (* | a = filterAction; cond = exp; body = exp { Filter(a, cond, body)} *) + (* | TEST; e = exp; END { Test(e) } *) + (* | e1 = exp; AT_SYMBOL; e2 = exp { ListConcat(e1, e2) } *) + (* | e1 = exp; CONS; e2 = exp { Cons(e1, e2) } *) + (* | e1 = exp; SEMI_COLON; e2 = exp { Seq(e1, e2) } *) + (* | QUESTION; s = STRING; { InvalidExp(s) } *) + (* | IN_AP; WILD {Deferral(InAp)} *) + (* | OUT_AP; WILD {Deferral(OutsideAp)} *) + (* | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} *) + (* | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} *) + (* | LESS_THAN; LESS_THAN; e = exp; QUESTION; s = SEXP_STRING; GREATER_THAN; GREATER_THAN {DynamicErrorHole(e, s)} *) + (* | b = BUILTIN; {BuiltinFun(b)} *) + (* | UNDEF; {Undefined} *) + (* | u = unExp { u } *) diff --git a/src/haz3lmenhir/dune b/src/haz3lmenhir/dune index 212543341a..0c1bf836b8 100644 --- a/src/haz3lmenhir/dune +++ b/src/haz3lmenhir/dune @@ -8,4 +8,5 @@ (ocamllex Lexer) (menhir - (modules Parser)) + (modules Parser) + (flags --explain --dump)) diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 8fd38d487f..615a36bdb2 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -231,12 +231,6 @@ let constructor_menhir = () => /* <<1 / 2 ? `a`>> */ -print_endline("SEXP seiralization:"); -InvalidOperationError.DivideByZero -|> InvalidOperationError.sexp_of_t -|> Sexplib.Sexp.to_string -|> print_endline; - let dynamic_error_hole_str = "<<(1/0) ? `DivideByZero`>> Int>"; let dynamic_error_hole_uexp: Exp.t = { ids: [id_at(0)], From de59c412226adb4265d18f37ba83e47ad9283f84 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 13 Sep 2024 11:06:20 -0400 Subject: [PATCH 046/281] Finished resolving shift/reduce conflicts in the menhir parser --- src/haz3lmenhir/Parser.automaton | 2225 ------------------------------ src/haz3lmenhir/Parser.conflicts | 332 ----- src/haz3lmenhir/Parser.mly | 66 +- 3 files changed, 36 insertions(+), 2587 deletions(-) delete mode 100644 src/haz3lmenhir/Parser.automaton delete mode 100644 src/haz3lmenhir/Parser.conflicts diff --git a/src/haz3lmenhir/Parser.automaton b/src/haz3lmenhir/Parser.automaton deleted file mode 100644 index 89329e2b8a..0000000000 --- a/src/haz3lmenhir/Parser.automaton +++ /dev/null @@ -1,2225 +0,0 @@ -State 0: -## Known stack suffix: -## -## LR(1) items: -program' -> . program [ # ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On program shift to state 127 --- On exp shift to state 128 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 1: -## Known stack suffix: -## STRING -## LR(1) items: -exp -> STRING . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> STRING - -State 2: -## Known stack suffix: -## OPEN_SQUARE_BRACKET -## LR(1) items: -exp -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On separated_nonempty_list(COMMA,exp) shift to state 118 --- On loption(separated_nonempty_list(COMMA,exp)) shift to state 125 --- On exp shift to state 121 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: --- On CLOSE_SQUARE_BRACKET --- reduce production loption(separated_nonempty_list(COMMA,exp)) -> - -State 3: -## Known stack suffix: -## OPEN_PAREN -## LR(1) items: -exp -> OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> OPEN_PAREN . exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 116 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 4: -## Known stack suffix: -## LET -## LR(1) items: -exp -> LET . pat SINGLE_EQUAL exp IN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 5 --- On TRUE shift to state 6 --- On STRING shift to state 7 --- On QUESTION shift to state 8 --- On OPEN_SQUARE_BRACKET shift to state 10 --- On OPEN_PAREN shift to state 11 --- On INT shift to state 12 --- On IDENT shift to state 13 --- On FLOAT shift to state 14 --- On FALSE shift to state 15 --- On CONSTRUCTOR_IDENT shift to state 16 --- On varPat shift to state 40 --- On patTuple shift to state 42 --- On pat shift to state 55 -## Reductions: - -State 5: -## Known stack suffix: -## WILD -## LR(1) items: -pat -> WILD . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> WILD - -State 6: -## Known stack suffix: -## TRUE -## LR(1) items: -pat -> TRUE . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> TRUE - -State 7: -## Known stack suffix: -## STRING -## LR(1) items: -pat -> STRING . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> STRING - -State 8: -## Known stack suffix: -## QUESTION -## LR(1) items: -pat -> QUESTION . STRING [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> QUESTION . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 9 -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> QUESTION - -State 9: -## Known stack suffix: -## QUESTION STRING -## LR(1) items: -pat -> QUESTION STRING . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> QUESTION STRING - -State 10: -## Known stack suffix: -## OPEN_SQUARE_BRACKET -## LR(1) items: -pat -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 5 --- On TRUE shift to state 6 --- On STRING shift to state 7 --- On QUESTION shift to state 8 --- On OPEN_SQUARE_BRACKET shift to state 10 --- On OPEN_PAREN shift to state 11 --- On INT shift to state 12 --- On IDENT shift to state 13 --- On FLOAT shift to state 14 --- On FALSE shift to state 15 --- On CONSTRUCTOR_IDENT shift to state 16 --- On varPat shift to state 40 --- On separated_nonempty_list(COMMA,pat) shift to state 41 --- On patTuple shift to state 42 --- On pat shift to state 43 --- On loption(separated_nonempty_list(COMMA,pat)) shift to state 53 -## Reductions: --- On CLOSE_SQUARE_BRACKET --- reduce production loption(separated_nonempty_list(COMMA,pat)) -> - -State 11: -## Known stack suffix: -## OPEN_PAREN -## LR(1) items: -patTuple -> OPEN_PAREN . loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 5 --- On TRUE shift to state 6 --- On STRING shift to state 7 --- On QUESTION shift to state 8 --- On OPEN_SQUARE_BRACKET shift to state 10 --- On OPEN_PAREN shift to state 11 --- On INT shift to state 12 --- On IDENT shift to state 13 --- On FLOAT shift to state 14 --- On FALSE shift to state 15 --- On CONSTRUCTOR_IDENT shift to state 16 --- On varPat shift to state 40 --- On separated_nonempty_list(COMMA,pat) shift to state 41 --- On patTuple shift to state 42 --- On pat shift to state 43 --- On loption(separated_nonempty_list(COMMA,pat)) shift to state 51 -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,pat)) -> - -State 12: -## Known stack suffix: -## INT -## LR(1) items: -pat -> INT . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> INT - -State 13: -## Known stack suffix: -## IDENT -## LR(1) items: -varPat -> IDENT . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production varPat -> IDENT - -State 14: -## Known stack suffix: -## FLOAT -## LR(1) items: -pat -> FLOAT . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> FLOAT - -State 15: -## Known stack suffix: -## FALSE -## LR(1) items: -pat -> FALSE . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> FALSE - -State 16: -## Known stack suffix: -## CONSTRUCTOR_IDENT -## LR(1) items: -pat -> CONSTRUCTOR_IDENT . COLON typ [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On COLON shift to state 17 -## Reductions: - -State 17: -## Known stack suffix: -## CONSTRUCTOR_IDENT COLON -## LR(1) items: -pat -> CONSTRUCTOR_IDENT COLON . typ [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 18 --- On UNIT shift to state 20 --- On STRING_TYPE shift to state 21 --- On QUESTION shift to state 22 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On BOOL_TYPE shift to state 28 --- On typ shift to state 39 -## Reductions: - -State 18: -## Known stack suffix: -## UNKNOWN -## LR(1) items: -typ -> UNKNOWN . INTERNAL [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On INTERNAL shift to state 19 -## Reductions: - -State 19: -## Known stack suffix: -## UNKNOWN INTERNAL -## LR(1) items: -typ -> UNKNOWN INTERNAL . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production typ -> UNKNOWN INTERNAL - -State 20: -## Known stack suffix: -## UNIT -## LR(1) items: -typ -> UNIT . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production typ -> UNIT - -State 21: -## Known stack suffix: -## STRING_TYPE -## LR(1) items: -typ -> STRING_TYPE . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production typ -> STRING_TYPE - -State 22: -## Known stack suffix: -## QUESTION -## LR(1) items: -typ -> QUESTION . STRING [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 23 -## Reductions: - -State 23: -## Known stack suffix: -## QUESTION STRING -## LR(1) items: -typ -> QUESTION STRING . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production typ -> QUESTION STRING - -State 24: -## Known stack suffix: -## OPEN_SQUARE_BRACKET -## LR(1) items: -typ -> OPEN_SQUARE_BRACKET . typ CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 18 --- On UNIT shift to state 20 --- On STRING_TYPE shift to state 21 --- On QUESTION shift to state 22 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On BOOL_TYPE shift to state 28 --- On typ shift to state 37 -## Reductions: - -State 25: -## Known stack suffix: -## OPEN_PAREN -## LR(1) items: -typ -> OPEN_PAREN . loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 18 --- On UNIT shift to state 20 --- On STRING_TYPE shift to state 21 --- On QUESTION shift to state 22 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On BOOL_TYPE shift to state 28 --- On typ shift to state 29 --- On separated_nonempty_list(COMMA,typ) shift to state 34 --- On loption(separated_nonempty_list(COMMA,typ)) shift to state 35 -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,typ)) -> - -State 26: -## Known stack suffix: -## INT_TYPE -## LR(1) items: -typ -> INT_TYPE . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production typ -> INT_TYPE - -State 27: -## Known stack suffix: -## FLOAT_TYPE -## LR(1) items: -typ -> FLOAT_TYPE . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production typ -> FLOAT_TYPE - -State 28: -## Known stack suffix: -## BOOL_TYPE -## LR(1) items: -typ -> BOOL_TYPE . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production typ -> BOOL_TYPE - -State 29: -## Known stack suffix: -## typ -## LR(1) items: -separated_nonempty_list(COMMA,typ) -> typ . [ CLOSE_PAREN ] -separated_nonempty_list(COMMA,typ) -> typ . COMMA separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ DASH_ARROW COMMA CLOSE_PAREN ] -## Transitions: --- On DASH_ARROW shift to state 30 --- On COMMA shift to state 32 -## Reductions: --- On CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,typ) -> typ - -State 30: -## Known stack suffix: -## typ DASH_ARROW -## LR(1) items: -typ -> typ DASH_ARROW . typ [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 18 --- On UNIT shift to state 20 --- On STRING_TYPE shift to state 21 --- On QUESTION shift to state 22 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On BOOL_TYPE shift to state 28 --- On typ shift to state 31 -## Reductions: - -State 31: -## Known stack suffix: -## typ DASH_ARROW typ -## LR(1) items: -typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ DASH_ARROW typ . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production typ -> typ DASH_ARROW typ - -State 32: -## Known stack suffix: -## typ COMMA -## LR(1) items: -separated_nonempty_list(COMMA,typ) -> typ COMMA . separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 18 --- On UNIT shift to state 20 --- On STRING_TYPE shift to state 21 --- On QUESTION shift to state 22 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On BOOL_TYPE shift to state 28 --- On typ shift to state 29 --- On separated_nonempty_list(COMMA,typ) shift to state 33 -## Reductions: - -State 33: -## Known stack suffix: -## typ COMMA separated_nonempty_list(COMMA,typ) -## LR(1) items: -separated_nonempty_list(COMMA,typ) -> typ COMMA separated_nonempty_list(COMMA,typ) . [ CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,typ) -> typ COMMA separated_nonempty_list(COMMA,typ) - -State 34: -## Known stack suffix: -## separated_nonempty_list(COMMA,typ) -## LR(1) items: -loption(separated_nonempty_list(COMMA,typ)) -> separated_nonempty_list(COMMA,typ) . [ CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,typ)) -> separated_nonempty_list(COMMA,typ) - -State 35: -## Known stack suffix: -## OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) -## LR(1) items: -typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) . CLOSE_PAREN [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On CLOSE_PAREN shift to state 36 -## Reductions: - -State 36: -## Known stack suffix: -## OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN -## LR(1) items: -typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN - -State 37: -## Known stack suffix: -## OPEN_SQUARE_BRACKET typ -## LR(1) items: -typ -> OPEN_SQUARE_BRACKET typ . CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ DASH_ARROW CLOSE_SQUARE_BRACKET ] -## Transitions: --- On DASH_ARROW shift to state 30 --- On CLOSE_SQUARE_BRACKET shift to state 38 -## Reductions: - -State 38: -## Known stack suffix: -## OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET -## LR(1) items: -typ -> OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET . [ TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN SINGLE_EQUAL QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production typ -> OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET - -State 39: -## Known stack suffix: -## CONSTRUCTOR_IDENT COLON typ -## LR(1) items: -pat -> CONSTRUCTOR_IDENT COLON typ . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On DASH_ARROW shift to state 30 -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> CONSTRUCTOR_IDENT COLON typ - -State 40: -## Known stack suffix: -## varPat -## LR(1) items: -pat -> varPat . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> varPat - -State 41: -## Known stack suffix: -## separated_nonempty_list(COMMA,pat) -## LR(1) items: -loption(separated_nonempty_list(COMMA,pat)) -> separated_nonempty_list(COMMA,pat) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,pat)) -> separated_nonempty_list(COMMA,pat) - -State 42: -## Known stack suffix: -## patTuple -## LR(1) items: -pat -> patTuple . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> patTuple - -State 43: -## Known stack suffix: -## pat -## LR(1) items: -pat -> pat . CONS pat [ OPEN_PAREN CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -separated_nonempty_list(COMMA,pat) -> pat . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -separated_nonempty_list(COMMA,pat) -> pat . COMMA separated_nonempty_list(COMMA,pat) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On OPEN_PAREN shift to state 44 --- On CONS shift to state 46 --- On COMMA shift to state 49 -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,pat) -> pat - -State 44: -## Known stack suffix: -## pat OPEN_PAREN -## LR(1) items: -pat -> pat OPEN_PAREN . pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 5 --- On TRUE shift to state 6 --- On STRING shift to state 7 --- On QUESTION shift to state 8 --- On OPEN_SQUARE_BRACKET shift to state 10 --- On OPEN_PAREN shift to state 11 --- On INT shift to state 12 --- On IDENT shift to state 13 --- On FLOAT shift to state 14 --- On FALSE shift to state 15 --- On CONSTRUCTOR_IDENT shift to state 16 --- On varPat shift to state 40 --- On patTuple shift to state 42 --- On pat shift to state 45 -## Reductions: - -State 45: -## Known stack suffix: -## pat OPEN_PAREN pat -## LR(1) items: -pat -> pat . CONS pat [ OPEN_PAREN CONS CLOSE_PAREN ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN CONS CLOSE_PAREN ] -pat -> pat OPEN_PAREN pat . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On OPEN_PAREN shift to state 44 --- On CONS shift to state 46 --- On CLOSE_PAREN shift to state 48 -## Reductions: - -State 46: -## Known stack suffix: -## pat CONS -## LR(1) items: -pat -> pat CONS . pat [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 5 --- On TRUE shift to state 6 --- On STRING shift to state 7 --- On QUESTION shift to state 8 --- On OPEN_SQUARE_BRACKET shift to state 10 --- On OPEN_PAREN shift to state 11 --- On INT shift to state 12 --- On IDENT shift to state 13 --- On FLOAT shift to state 14 --- On FALSE shift to state 15 --- On CONSTRUCTOR_IDENT shift to state 16 --- On varPat shift to state 40 --- On patTuple shift to state 42 --- On pat shift to state 47 -## Reductions: - -State 47: -## Known stack suffix: -## pat CONS pat -## LR(1) items: -pat -> pat . CONS pat [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat CONS pat . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On OPEN_PAREN shift to state 44 -## Reductions: --- On SINGLE_EQUAL EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> pat CONS pat - -State 48: -## Known stack suffix: -## pat OPEN_PAREN pat CLOSE_PAREN -## LR(1) items: -pat -> pat OPEN_PAREN pat CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> pat OPEN_PAREN pat CLOSE_PAREN - -State 49: -## Known stack suffix: -## pat COMMA -## LR(1) items: -separated_nonempty_list(COMMA,pat) -> pat COMMA . separated_nonempty_list(COMMA,pat) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 5 --- On TRUE shift to state 6 --- On STRING shift to state 7 --- On QUESTION shift to state 8 --- On OPEN_SQUARE_BRACKET shift to state 10 --- On OPEN_PAREN shift to state 11 --- On INT shift to state 12 --- On IDENT shift to state 13 --- On FLOAT shift to state 14 --- On FALSE shift to state 15 --- On CONSTRUCTOR_IDENT shift to state 16 --- On varPat shift to state 40 --- On separated_nonempty_list(COMMA,pat) shift to state 50 --- On patTuple shift to state 42 --- On pat shift to state 43 -## Reductions: - -State 50: -## Known stack suffix: -## pat COMMA separated_nonempty_list(COMMA,pat) -## LR(1) items: -separated_nonempty_list(COMMA,pat) -> pat COMMA separated_nonempty_list(COMMA,pat) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,pat) -> pat COMMA separated_nonempty_list(COMMA,pat) - -State 51: -## Known stack suffix: -## OPEN_PAREN loption(separated_nonempty_list(COMMA,pat)) -## LR(1) items: -patTuple -> OPEN_PAREN loption(separated_nonempty_list(COMMA,pat)) . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On CLOSE_PAREN shift to state 52 -## Reductions: - -State 52: -## Known stack suffix: -## OPEN_PAREN loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN -## LR(1) items: -patTuple -> OPEN_PAREN loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production patTuple -> OPEN_PAREN loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN - -State 53: -## Known stack suffix: -## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) -## LR(1) items: -pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) . CLOSE_SQUARE_BRACKET [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On CLOSE_SQUARE_BRACKET shift to state 54 -## Reductions: - -State 54: -## Known stack suffix: -## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET -## LR(1) items: -pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET . [ SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN EQUAL_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET - -State 55: -## Known stack suffix: -## LET pat -## LR(1) items: -exp -> LET pat . SINGLE_EQUAL exp IN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . CONS pat [ SINGLE_EQUAL OPEN_PAREN CONS ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN CONS ] -## Transitions: --- On SINGLE_EQUAL shift to state 56 --- On OPEN_PAREN shift to state 44 --- On CONS shift to state 46 -## Reductions: - -State 56: -## Known stack suffix: -## LET pat SINGLE_EQUAL -## LR(1) items: -exp -> LET pat SINGLE_EQUAL . exp IN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 113 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 57: -## Known stack suffix: -## INT -## LR(1) items: -exp -> INT . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> INT - -State 58: -## Known stack suffix: -## IF -## LR(1) items: -exp -> IF . exp THEN exp ELSE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 108 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 59: -## Known stack suffix: -## IDENT -## LR(1) items: -exp -> IDENT . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> IDENT - -State 60: -## Known stack suffix: -## FLOAT -## LR(1) items: -exp -> FLOAT . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> FLOAT - -State 61: -## Known stack suffix: -## CONSTRUCTOR_IDENT -## LR(1) items: -exp -> CONSTRUCTOR_IDENT . COLON typ [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On COLON shift to state 62 -## Reductions: - -State 62: -## Known stack suffix: -## CONSTRUCTOR_IDENT COLON -## LR(1) items: -exp -> CONSTRUCTOR_IDENT COLON . typ [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 18 --- On UNIT shift to state 20 --- On STRING_TYPE shift to state 21 --- On QUESTION shift to state 22 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On BOOL_TYPE shift to state 28 --- On typ shift to state 63 -## Reductions: - -State 63: -## Known stack suffix: -## CONSTRUCTOR_IDENT COLON typ -## LR(1) items: -exp -> CONSTRUCTOR_IDENT COLON typ . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE DASH_ARROW COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On DASH_ARROW shift to state 30 -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> CONSTRUCTOR_IDENT COLON typ - -State 64: -## Known stack suffix: -## CASE -## LR(1) items: -case -> CASE . exp list(rul) END [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 65 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 65: -## Known stack suffix: -## CASE exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . POWER exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -case -> CASE exp . list(rul) END [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -## Transitions: --- On TURNSTILE shift to state 66 --- On TIMES shift to state 70 --- On QUESTION shift to state 72 --- On POWER shift to state 81 --- On PLUS shift to state 85 --- On OPEN_PAREN shift to state 78 --- On NOT_EQUAL shift to state 87 --- On MINUS shift to state 89 --- On LESS_THAN_EQUAL shift to state 91 --- On GREATER_THAN_EQUAL shift to state 93 --- On GREATER_THAN shift to state 95 --- On DOUBLE_EQUAL shift to state 97 --- On DIVIDE shift to state 99 --- On rul shift to state 104 --- On list(rul) shift to state 106 -## Reductions: --- On END --- reduce production list(rul) -> - -State 66: -## Known stack suffix: -## TURNSTILE -## LR(1) items: -rul -> TURNSTILE . pat EQUAL_ARROW exp [ TURNSTILE END ] -## Transitions: --- On WILD shift to state 5 --- On TRUE shift to state 6 --- On STRING shift to state 7 --- On QUESTION shift to state 8 --- On OPEN_SQUARE_BRACKET shift to state 10 --- On OPEN_PAREN shift to state 11 --- On INT shift to state 12 --- On IDENT shift to state 13 --- On FLOAT shift to state 14 --- On FALSE shift to state 15 --- On CONSTRUCTOR_IDENT shift to state 16 --- On varPat shift to state 40 --- On patTuple shift to state 42 --- On pat shift to state 67 -## Reductions: - -State 67: -## Known stack suffix: -## TURNSTILE pat -## LR(1) items: -pat -> pat . CONS pat [ OPEN_PAREN EQUAL_ARROW CONS ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN EQUAL_ARROW CONS ] -rul -> TURNSTILE pat . EQUAL_ARROW exp [ TURNSTILE END ] -## Transitions: --- On OPEN_PAREN shift to state 44 --- On EQUAL_ARROW shift to state 68 --- On CONS shift to state 46 -## Reductions: - -State 68: -## Known stack suffix: -## TURNSTILE pat EQUAL_ARROW -## LR(1) items: -rul -> TURNSTILE pat EQUAL_ARROW . exp [ TURNSTILE END ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 69 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 69: -## Known stack suffix: -## TURNSTILE pat EQUAL_ARROW exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . POWER exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL DIVIDE ] -rul -> TURNSTILE pat EQUAL_ARROW exp . [ TURNSTILE END ] -## Transitions: --- On TIMES shift to state 70 --- On QUESTION shift to state 72 --- On POWER shift to state 81 --- On PLUS shift to state 85 --- On OPEN_PAREN shift to state 78 --- On NOT_EQUAL shift to state 87 --- On MINUS shift to state 89 --- On LESS_THAN_EQUAL shift to state 91 --- On GREATER_THAN_EQUAL shift to state 93 --- On GREATER_THAN shift to state 95 --- On DOUBLE_EQUAL shift to state 97 --- On DIVIDE shift to state 99 -## Reductions: --- On TURNSTILE END --- reduce production rul -> TURNSTILE pat EQUAL_ARROW exp - -State 70: -## Known stack suffix: -## exp TIMES -## LR(1) items: -binExp -> exp TIMES . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 71 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 71: -## Known stack suffix: -## exp TIMES exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp TIMES exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On QUESTION shift to state 72 --- On OPEN_PAREN shift to state 78 -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp TIMES exp -** Conflict on QUESTION - -State 72: -## Known stack suffix: -## exp QUESTION -## LR(1) items: -exp -> exp QUESTION . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On LESS_THAN shift to state 73 -## Reductions: - -State 73: -## Known stack suffix: -## exp QUESTION LESS_THAN -## LR(1) items: -exp -> exp QUESTION LESS_THAN . typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 18 --- On UNIT shift to state 20 --- On STRING_TYPE shift to state 21 --- On QUESTION shift to state 22 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On BOOL_TYPE shift to state 28 --- On typ shift to state 74 -## Reductions: - -State 74: -## Known stack suffix: -## exp QUESTION LESS_THAN typ -## LR(1) items: -exp -> exp QUESTION LESS_THAN typ . EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] -## Transitions: --- On EQUAL_ARROW shift to state 75 --- On DASH_ARROW shift to state 30 -## Reductions: - -State 75: -## Known stack suffix: -## exp QUESTION LESS_THAN typ EQUAL_ARROW -## LR(1) items: -exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW . typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 18 --- On UNIT shift to state 20 --- On STRING_TYPE shift to state 21 --- On QUESTION shift to state 22 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On BOOL_TYPE shift to state 28 --- On typ shift to state 76 -## Reductions: - -State 76: -## Known stack suffix: -## exp QUESTION LESS_THAN typ EQUAL_ARROW typ -## LR(1) items: -exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW typ . GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ GREATER_THAN DASH_ARROW ] -## Transitions: --- On GREATER_THAN shift to state 77 --- On DASH_ARROW shift to state 30 -## Reductions: - -State 77: -## Known stack suffix: -## exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN -## LR(1) items: -exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -State 78: -## Known stack suffix: -## exp OPEN_PAREN -## LR(1) items: -exp -> exp OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp OPEN_PAREN . WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 79 --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 102 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 79: -## Known stack suffix: -## exp OPEN_PAREN WILD -## LR(1) items: -exp -> exp OPEN_PAREN WILD . exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 80 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 80: -## Known stack suffix: -## exp OPEN_PAREN WILD exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -exp -> exp OPEN_PAREN WILD exp . CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -## Transitions: --- On TIMES shift to state 70 --- On QUESTION shift to state 72 --- On POWER shift to state 81 --- On PLUS shift to state 85 --- On OPEN_PAREN shift to state 78 --- On NOT_EQUAL shift to state 87 --- On MINUS shift to state 89 --- On LESS_THAN_EQUAL shift to state 91 --- On GREATER_THAN_EQUAL shift to state 93 --- On GREATER_THAN shift to state 95 --- On DOUBLE_EQUAL shift to state 97 --- On DIVIDE shift to state 99 --- On CLOSE_PAREN shift to state 101 -## Reductions: - -State 81: -## Known stack suffix: -## exp POWER -## LR(1) items: -binExp -> exp POWER . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 82 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 82: -## Known stack suffix: -## exp POWER exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp POWER exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On QUESTION shift to state 72 --- On OPEN_PAREN shift to state 78 -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp POWER exp -** Conflict on QUESTION - -State 83: -## Known stack suffix: -## case -## LR(1) items: -exp -> case . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> case - -State 84: -## Known stack suffix: -## binExp -## LR(1) items: -exp -> binExp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> binExp - -State 85: -## Known stack suffix: -## exp PLUS -## LR(1) items: -binExp -> exp PLUS . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 86 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 86: -## Known stack suffix: -## exp PLUS exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp PLUS exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On QUESTION shift to state 72 --- On OPEN_PAREN shift to state 78 -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp PLUS exp -** Conflict on QUESTION - -State 87: -## Known stack suffix: -## exp NOT_EQUAL -## LR(1) items: -binExp -> exp NOT_EQUAL . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 88 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 88: -## Known stack suffix: -## exp NOT_EQUAL exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp NOT_EQUAL exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On QUESTION shift to state 72 --- On OPEN_PAREN shift to state 78 -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp NOT_EQUAL exp -** Conflict on QUESTION - -State 89: -## Known stack suffix: -## exp MINUS -## LR(1) items: -binExp -> exp MINUS . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 90 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 90: -## Known stack suffix: -## exp MINUS exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp MINUS exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On QUESTION shift to state 72 --- On OPEN_PAREN shift to state 78 -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp MINUS exp -** Conflict on QUESTION - -State 91: -## Known stack suffix: -## exp LESS_THAN_EQUAL -## LR(1) items: -binExp -> exp LESS_THAN_EQUAL . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 92 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 92: -## Known stack suffix: -## exp LESS_THAN_EQUAL exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp LESS_THAN_EQUAL exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On QUESTION shift to state 72 --- On OPEN_PAREN shift to state 78 -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp LESS_THAN_EQUAL exp -** Conflict on QUESTION - -State 93: -## Known stack suffix: -## exp GREATER_THAN_EQUAL -## LR(1) items: -binExp -> exp GREATER_THAN_EQUAL . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 94 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 94: -## Known stack suffix: -## exp GREATER_THAN_EQUAL exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp GREATER_THAN_EQUAL exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On QUESTION shift to state 72 --- On OPEN_PAREN shift to state 78 -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp GREATER_THAN_EQUAL exp -** Conflict on QUESTION - -State 95: -## Known stack suffix: -## exp GREATER_THAN -## LR(1) items: -binExp -> exp GREATER_THAN . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 96 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 96: -## Known stack suffix: -## exp GREATER_THAN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp GREATER_THAN exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On QUESTION shift to state 72 --- On OPEN_PAREN shift to state 78 -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp GREATER_THAN exp -** Conflict on QUESTION - -State 97: -## Known stack suffix: -## exp DOUBLE_EQUAL -## LR(1) items: -binExp -> exp DOUBLE_EQUAL . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 98 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 98: -## Known stack suffix: -## exp DOUBLE_EQUAL exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp DOUBLE_EQUAL exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On QUESTION shift to state 72 --- On OPEN_PAREN shift to state 78 -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp DOUBLE_EQUAL exp -** Conflict on QUESTION - -State 99: -## Known stack suffix: -## exp DIVIDE -## LR(1) items: -binExp -> exp DIVIDE . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 100 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 100: -## Known stack suffix: -## exp DIVIDE exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp DIVIDE exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On QUESTION shift to state 72 --- On OPEN_PAREN shift to state 78 -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp DIVIDE exp -** Conflict on QUESTION - -State 101: -## Known stack suffix: -## exp OPEN_PAREN WILD exp CLOSE_PAREN -## LR(1) items: -exp -> exp OPEN_PAREN WILD exp CLOSE_PAREN . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> exp OPEN_PAREN WILD exp CLOSE_PAREN - -State 102: -## Known stack suffix: -## exp OPEN_PAREN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -exp -> exp OPEN_PAREN exp . CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE CLOSE_PAREN ] -## Transitions: --- On TIMES shift to state 70 --- On QUESTION shift to state 72 --- On POWER shift to state 81 --- On PLUS shift to state 85 --- On OPEN_PAREN shift to state 78 --- On NOT_EQUAL shift to state 87 --- On MINUS shift to state 89 --- On LESS_THAN_EQUAL shift to state 91 --- On GREATER_THAN_EQUAL shift to state 93 --- On GREATER_THAN shift to state 95 --- On DOUBLE_EQUAL shift to state 97 --- On DIVIDE shift to state 99 --- On CLOSE_PAREN shift to state 103 -## Reductions: - -State 103: -## Known stack suffix: -## exp OPEN_PAREN exp CLOSE_PAREN -## LR(1) items: -exp -> exp OPEN_PAREN exp CLOSE_PAREN . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> exp OPEN_PAREN exp CLOSE_PAREN - -State 104: -## Known stack suffix: -## rul -## LR(1) items: -list(rul) -> rul . list(rul) [ END ] -## Transitions: --- On TURNSTILE shift to state 66 --- On rul shift to state 104 --- On list(rul) shift to state 105 -## Reductions: --- On END --- reduce production list(rul) -> - -State 105: -## Known stack suffix: -## rul list(rul) -## LR(1) items: -list(rul) -> rul list(rul) . [ END ] -## Transitions: -## Reductions: --- On END --- reduce production list(rul) -> rul list(rul) - -State 106: -## Known stack suffix: -## CASE exp list(rul) -## LR(1) items: -case -> CASE exp list(rul) . END [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On END shift to state 107 -## Reductions: - -State 107: -## Known stack suffix: -## CASE exp list(rul) END -## LR(1) items: -case -> CASE exp list(rul) END . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production case -> CASE exp list(rul) END - -State 108: -## Known stack suffix: -## IF exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . MINUS exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . TIMES exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . POWER exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . DIVIDE exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . NOT_EQUAL exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . GREATER_THAN exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -exp -> IF exp . THEN exp ELSE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -## Transitions: --- On TIMES shift to state 70 --- On THEN shift to state 109 --- On QUESTION shift to state 72 --- On POWER shift to state 81 --- On PLUS shift to state 85 --- On OPEN_PAREN shift to state 78 --- On NOT_EQUAL shift to state 87 --- On MINUS shift to state 89 --- On LESS_THAN_EQUAL shift to state 91 --- On GREATER_THAN_EQUAL shift to state 93 --- On GREATER_THAN shift to state 95 --- On DOUBLE_EQUAL shift to state 97 --- On DIVIDE shift to state 99 -## Reductions: - -State 109: -## Known stack suffix: -## IF exp THEN -## LR(1) items: -exp -> IF exp THEN . exp ELSE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 110 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 110: -## Known stack suffix: -## IF exp THEN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -exp -> IF exp THEN exp . ELSE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL DIVIDE ] -## Transitions: --- On TIMES shift to state 70 --- On QUESTION shift to state 72 --- On POWER shift to state 81 --- On PLUS shift to state 85 --- On OPEN_PAREN shift to state 78 --- On NOT_EQUAL shift to state 87 --- On MINUS shift to state 89 --- On LESS_THAN_EQUAL shift to state 91 --- On GREATER_THAN_EQUAL shift to state 93 --- On GREATER_THAN shift to state 95 --- On ELSE shift to state 111 --- On DOUBLE_EQUAL shift to state 97 --- On DIVIDE shift to state 99 -## Reductions: - -State 111: -## Known stack suffix: -## IF exp THEN exp ELSE -## LR(1) items: -exp -> IF exp THEN exp ELSE . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 112 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 112: -## Known stack suffix: -## IF exp THEN exp ELSE exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> IF exp THEN exp ELSE exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On TIMES shift to state 70 --- On QUESTION shift to state 72 --- On POWER shift to state 81 --- On PLUS shift to state 85 --- On OPEN_PAREN shift to state 78 --- On NOT_EQUAL shift to state 87 --- On MINUS shift to state 89 --- On LESS_THAN_EQUAL shift to state 91 --- On GREATER_THAN_EQUAL shift to state 93 --- On GREATER_THAN shift to state 95 --- On DOUBLE_EQUAL shift to state 97 --- On DIVIDE shift to state 99 -## Reductions: --- On TURNSTILE THEN QUESTION IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> IF exp THEN exp ELSE exp -** Conflict on QUESTION - -State 113: -## Known stack suffix: -## LET pat SINGLE_EQUAL exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -exp -> LET pat SINGLE_EQUAL exp . IN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE ] -## Transitions: --- On TIMES shift to state 70 --- On QUESTION shift to state 72 --- On POWER shift to state 81 --- On PLUS shift to state 85 --- On OPEN_PAREN shift to state 78 --- On NOT_EQUAL shift to state 87 --- On MINUS shift to state 89 --- On LESS_THAN_EQUAL shift to state 91 --- On IN shift to state 114 --- On GREATER_THAN_EQUAL shift to state 93 --- On GREATER_THAN shift to state 95 --- On DOUBLE_EQUAL shift to state 97 --- On DIVIDE shift to state 99 -## Reductions: - -State 114: -## Known stack suffix: -## LET pat SINGLE_EQUAL exp IN -## LR(1) items: -exp -> LET pat SINGLE_EQUAL exp IN . exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On exp shift to state 115 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 115: -## Known stack suffix: -## LET pat SINGLE_EQUAL exp IN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> LET pat SINGLE_EQUAL exp IN exp . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On TIMES shift to state 70 --- On QUESTION shift to state 72 --- On POWER shift to state 81 --- On PLUS shift to state 85 --- On OPEN_PAREN shift to state 78 --- On NOT_EQUAL shift to state 87 --- On MINUS shift to state 89 --- On LESS_THAN_EQUAL shift to state 91 --- On GREATER_THAN_EQUAL shift to state 93 --- On GREATER_THAN shift to state 95 --- On DOUBLE_EQUAL shift to state 97 --- On DIVIDE shift to state 99 -## Reductions: --- On TURNSTILE THEN QUESTION IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> LET pat SINGLE_EQUAL exp IN exp -** Conflict on QUESTION - -State 116: -## Known stack suffix: -## OPEN_PAREN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -exp -> OPEN_PAREN exp . CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> OPEN_PAREN exp . COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_PAREN ] -## Transitions: --- On TIMES shift to state 70 --- On QUESTION shift to state 72 --- On POWER shift to state 81 --- On PLUS shift to state 85 --- On OPEN_PAREN shift to state 78 --- On NOT_EQUAL shift to state 87 --- On MINUS shift to state 89 --- On LESS_THAN_EQUAL shift to state 91 --- On GREATER_THAN_EQUAL shift to state 93 --- On GREATER_THAN shift to state 95 --- On DOUBLE_EQUAL shift to state 97 --- On DIVIDE shift to state 99 --- On COMMA shift to state 117 --- On CLOSE_PAREN shift to state 124 -## Reductions: - -State 117: -## Known stack suffix: -## OPEN_PAREN exp COMMA -## LR(1) items: -exp -> OPEN_PAREN exp COMMA . loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On separated_nonempty_list(COMMA,exp) shift to state 118 --- On loption(separated_nonempty_list(COMMA,exp)) shift to state 119 --- On exp shift to state 121 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,exp)) -> - -State 118: -## Known stack suffix: -## separated_nonempty_list(COMMA,exp) -## LR(1) items: -loption(separated_nonempty_list(COMMA,exp)) -> separated_nonempty_list(COMMA,exp) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,exp)) -> separated_nonempty_list(COMMA,exp) - -State 119: -## Known stack suffix: -## OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) -## LR(1) items: -exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) . CLOSE_PAREN [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On CLOSE_PAREN shift to state 120 -## Reductions: - -State 120: -## Known stack suffix: -## OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN -## LR(1) items: -exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN - -State 121: -## Known stack suffix: -## exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -separated_nonempty_list(COMMA,exp) -> exp . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -separated_nonempty_list(COMMA,exp) -> exp . COMMA separated_nonempty_list(COMMA,exp) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On TIMES shift to state 70 --- On QUESTION shift to state 72 --- On POWER shift to state 81 --- On PLUS shift to state 85 --- On OPEN_PAREN shift to state 78 --- On NOT_EQUAL shift to state 87 --- On MINUS shift to state 89 --- On LESS_THAN_EQUAL shift to state 91 --- On GREATER_THAN_EQUAL shift to state 93 --- On GREATER_THAN shift to state 95 --- On DOUBLE_EQUAL shift to state 97 --- On DIVIDE shift to state 99 --- On COMMA shift to state 122 -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,exp) -> exp - -State 122: -## Known stack suffix: -## exp COMMA -## LR(1) items: -separated_nonempty_list(COMMA,exp) -> exp COMMA . separated_nonempty_list(COMMA,exp) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 1 --- On OPEN_SQUARE_BRACKET shift to state 2 --- On OPEN_PAREN shift to state 3 --- On LET shift to state 4 --- On INT shift to state 57 --- On IF shift to state 58 --- On IDENT shift to state 59 --- On FLOAT shift to state 60 --- On CONSTRUCTOR_IDENT shift to state 61 --- On CASE shift to state 64 --- On separated_nonempty_list(COMMA,exp) shift to state 123 --- On exp shift to state 121 --- On case shift to state 83 --- On binExp shift to state 84 -## Reductions: - -State 123: -## Known stack suffix: -## exp COMMA separated_nonempty_list(COMMA,exp) -## LR(1) items: -separated_nonempty_list(COMMA,exp) -> exp COMMA separated_nonempty_list(COMMA,exp) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,exp) -> exp COMMA separated_nonempty_list(COMMA,exp) - -State 124: -## Known stack suffix: -## OPEN_PAREN exp CLOSE_PAREN -## LR(1) items: -exp -> OPEN_PAREN exp CLOSE_PAREN . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> OPEN_PAREN exp CLOSE_PAREN - -State 125: -## Known stack suffix: -## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) -## LR(1) items: -exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) . CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On CLOSE_SQUARE_BRACKET shift to state 126 -## Reductions: - -State 126: -## Known stack suffix: -## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET -## LR(1) items: -exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET . [ TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES THEN QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET - -State 127: -## Known stack suffix: -## program -## LR(1) items: -program' -> program . [ # ] -## Transitions: -## Reductions: --- On # --- accept program - -State 128: -## Known stack suffix: -## exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -binExp -> exp . MINUS exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -binExp -> exp . TIMES exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -binExp -> exp . POWER exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -binExp -> exp . DIVIDE exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -binExp -> exp . NOT_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -binExp -> exp . GREATER_THAN exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -exp -> exp . OPEN_PAREN WILD exp CLOSE_PAREN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES QUESTION POWER PLUS OPEN_PAREN NOT_EQUAL MINUS LESS_THAN_EQUAL GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL DIVIDE ] -program -> exp . EOF [ # ] -## Transitions: --- On TIMES shift to state 70 --- On QUESTION shift to state 72 --- On POWER shift to state 81 --- On PLUS shift to state 85 --- On OPEN_PAREN shift to state 78 --- On NOT_EQUAL shift to state 87 --- On MINUS shift to state 89 --- On LESS_THAN_EQUAL shift to state 91 --- On GREATER_THAN_EQUAL shift to state 93 --- On GREATER_THAN shift to state 95 --- On EOF shift to state 129 --- On DOUBLE_EQUAL shift to state 97 --- On DIVIDE shift to state 99 -## Reductions: - -State 129: -## Known stack suffix: -## exp EOF -## LR(1) items: -program -> exp EOF . [ # ] -## Transitions: -## Reductions: --- On # --- reduce production program -> exp EOF - diff --git a/src/haz3lmenhir/Parser.conflicts b/src/haz3lmenhir/Parser.conflicts deleted file mode 100644 index 12b9fc39ae..0000000000 --- a/src/haz3lmenhir/Parser.conflicts +++ /dev/null @@ -1,332 +0,0 @@ - -** Conflict (shift/reduce) in state 115. -** Token involved: QUESTION -** This state is reached from program after reading: - -LET pat SINGLE_EQUAL exp IN exp - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 115, looking ahead at QUESTION, reducing production -** exp -> LET pat SINGLE_EQUAL exp IN exp -** is permitted because of the following sub-derivation: - -exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears -LET pat SINGLE_EQUAL exp IN exp . - -** In state 115, looking ahead at QUESTION, shifting is permitted -** because of the following sub-derivation: - -LET pat SINGLE_EQUAL exp IN exp - exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -** Conflict (shift/reduce) in state 112. -** Token involved: QUESTION -** This state is reached from program after reading: - -IF exp THEN exp ELSE exp - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 112, looking ahead at QUESTION, reducing production -** exp -> IF exp THEN exp ELSE exp -** is permitted because of the following sub-derivation: - -exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears -IF exp THEN exp ELSE exp . - -** In state 112, looking ahead at QUESTION, shifting is permitted -** because of the following sub-derivation: - -IF exp THEN exp ELSE exp - exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -** Conflict (shift/reduce) in state 100. -** Token involved: QUESTION -** This state is reached from program after reading: - -exp DIVIDE exp - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 100, looking ahead at QUESTION, reducing production -** binExp -> exp DIVIDE exp -** is permitted because of the following sub-derivation: - -exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears -binExp // lookahead token is inherited -exp DIVIDE exp . - -** In state 100, looking ahead at QUESTION, shifting is permitted -** because of the following sub-derivation: - -binExp -exp DIVIDE exp - exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -** Conflict (shift/reduce) in state 98. -** Token involved: QUESTION -** This state is reached from program after reading: - -exp DOUBLE_EQUAL exp - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 98, looking ahead at QUESTION, reducing production -** binExp -> exp DOUBLE_EQUAL exp -** is permitted because of the following sub-derivation: - -exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears -binExp // lookahead token is inherited -exp DOUBLE_EQUAL exp . - -** In state 98, looking ahead at QUESTION, shifting is permitted -** because of the following sub-derivation: - -binExp -exp DOUBLE_EQUAL exp - exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -** Conflict (shift/reduce) in state 96. -** Token involved: QUESTION -** This state is reached from program after reading: - -exp GREATER_THAN exp - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 96, looking ahead at QUESTION, reducing production -** binExp -> exp GREATER_THAN exp -** is permitted because of the following sub-derivation: - -exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears -binExp // lookahead token is inherited -exp GREATER_THAN exp . - -** In state 96, looking ahead at QUESTION, shifting is permitted -** because of the following sub-derivation: - -binExp -exp GREATER_THAN exp - exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -** Conflict (shift/reduce) in state 94. -** Token involved: QUESTION -** This state is reached from program after reading: - -exp GREATER_THAN_EQUAL exp - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 94, looking ahead at QUESTION, reducing production -** binExp -> exp GREATER_THAN_EQUAL exp -** is permitted because of the following sub-derivation: - -exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears -binExp // lookahead token is inherited -exp GREATER_THAN_EQUAL exp . - -** In state 94, looking ahead at QUESTION, shifting is permitted -** because of the following sub-derivation: - -binExp -exp GREATER_THAN_EQUAL exp - exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -** Conflict (shift/reduce) in state 92. -** Token involved: QUESTION -** This state is reached from program after reading: - -exp LESS_THAN_EQUAL exp - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 92, looking ahead at QUESTION, reducing production -** binExp -> exp LESS_THAN_EQUAL exp -** is permitted because of the following sub-derivation: - -exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears -binExp // lookahead token is inherited -exp LESS_THAN_EQUAL exp . - -** In state 92, looking ahead at QUESTION, shifting is permitted -** because of the following sub-derivation: - -binExp -exp LESS_THAN_EQUAL exp - exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -** Conflict (shift/reduce) in state 90. -** Token involved: QUESTION -** This state is reached from program after reading: - -exp MINUS exp - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 90, looking ahead at QUESTION, reducing production -** binExp -> exp MINUS exp -** is permitted because of the following sub-derivation: - -exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears -binExp // lookahead token is inherited -exp MINUS exp . - -** In state 90, looking ahead at QUESTION, shifting is permitted -** because of the following sub-derivation: - -binExp -exp MINUS exp - exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -** Conflict (shift/reduce) in state 88. -** Token involved: QUESTION -** This state is reached from program after reading: - -exp NOT_EQUAL exp - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 88, looking ahead at QUESTION, reducing production -** binExp -> exp NOT_EQUAL exp -** is permitted because of the following sub-derivation: - -exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears -binExp // lookahead token is inherited -exp NOT_EQUAL exp . - -** In state 88, looking ahead at QUESTION, shifting is permitted -** because of the following sub-derivation: - -binExp -exp NOT_EQUAL exp - exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -** Conflict (shift/reduce) in state 86. -** Token involved: QUESTION -** This state is reached from program after reading: - -exp PLUS exp - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 86, looking ahead at QUESTION, reducing production -** binExp -> exp PLUS exp -** is permitted because of the following sub-derivation: - -exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears -binExp // lookahead token is inherited -exp PLUS exp . - -** In state 86, looking ahead at QUESTION, shifting is permitted -** because of the following sub-derivation: - -binExp -exp PLUS exp - exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -** Conflict (shift/reduce) in state 82. -** Token involved: QUESTION -** This state is reached from program after reading: - -exp POWER exp - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 82, looking ahead at QUESTION, reducing production -** binExp -> exp POWER exp -** is permitted because of the following sub-derivation: - -exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears -binExp // lookahead token is inherited -exp POWER exp . - -** In state 82, looking ahead at QUESTION, shifting is permitted -** because of the following sub-derivation: - -binExp -exp POWER exp - exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -** Conflict (shift/reduce) in state 71. -** Token involved: QUESTION -** This state is reached from program after reading: - -exp TIMES exp - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 71, looking ahead at QUESTION, reducing production -** binExp -> exp TIMES exp -** is permitted because of the following sub-derivation: - -exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN // lookahead token appears -binExp // lookahead token is inherited -exp TIMES exp . - -** In state 71, looking ahead at QUESTION, shifting is permitted -** because of the following sub-derivation: - -binExp -exp TIMES exp - exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index ac5cfb6039..c7030fd5af 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -100,11 +100,24 @@ open AST %nonassoc LET_EXP %left PLUS MINUS TIMES POWER DIVIDE DOUBLE_EQUAL NOT_EQUAL LESS_THAN LESS_THAN_EQUAL GREATER_THAN GREATER_THAN_EQUAL + +%left PLUS_FLOAT MINUS_FLOAT TIMES_FLOAT POWER_FLOAT DIVIDE_FLOAT DOUBLE_EQUAL_FLOAT NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT + (* Other *) %left DASH_ARROW %left CONS %left OPEN_PAREN - +%right QUESTION +%left COLON +%left COMMA +%left AT_SYMBOL +%left SEMI_COLON +%left IN +%left DOLLAR_SIGN +%left L_NOT L_AND L_OR + +(* Might not be correct - milan *) +%left IDENT %type exp @@ -152,7 +165,7 @@ program: | b = boolOp { b } binExp: - | e1 = exp; b = intOp; e2 = exp { BinExp (e1, b, e2) } + | e1 = exp; b = binOp; e2 = exp { BinExp (e1, b, e2) } typ: | QUESTION; s = STRING { InvalidTyp(s) } @@ -178,7 +191,6 @@ pat: | c = CONSTRUCTOR_IDENT; COLON; t = typ; { ConstructorPat(c, t) } | p = varPat {p} | t = patTuple { t } - (* | t = typeAnn { t } *) | i = INT { IntPat i } | f = FLOAT { FloatPat f } | s = STRING { StringPat s} @@ -192,9 +204,6 @@ pat: patTuple: | OPEN_PAREN; pats = separated_list(COMMA, pat); CLOSE_PAREN { TuplePat(pats) } -(* typeAnn: *) - (* | p = pat; COLON; t = typ { TypeAnn(p, t) } *) - rul: | TURNSTILE; p = pat; EQUAL_ARROW; e = exp; { (p, e) } @@ -226,9 +235,6 @@ unExp: | L_NOT; e = exp {UnOp(Bool(Not), e)} -(* apExp: *) -(* | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } *) - exp: | b = binExp { b } | i = INT { Int i } @@ -245,24 +251,24 @@ exp: | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } %prec LET_EXP | i = ifExp { i } | e1 = exp; QUESTION; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN {FailedCast(e1, t1, t2)} - (* | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } *) - (* | TRUE { Bool true } *) - (* | f = funExp {f} *) - (* | FALSE { Bool false } *) - (* | FIX; p = pat; DASH_ARROW; e = exp { FixF(p, e) } *) - (* | TYP_FUN; t = tpat; DASH_ARROW; e = exp {TypFun(t, e)} *) - (* | QUESTION { EmptyHole } *) - (* | a = filterAction; cond = exp; body = exp { Filter(a, cond, body)} *) - (* | TEST; e = exp; END { Test(e) } *) - (* | e1 = exp; AT_SYMBOL; e2 = exp { ListConcat(e1, e2) } *) - (* | e1 = exp; CONS; e2 = exp { Cons(e1, e2) } *) - (* | e1 = exp; SEMI_COLON; e2 = exp { Seq(e1, e2) } *) - (* | QUESTION; s = STRING; { InvalidExp(s) } *) - (* | IN_AP; WILD {Deferral(InAp)} *) - (* | OUT_AP; WILD {Deferral(OutsideAp)} *) - (* | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} *) - (* | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} *) - (* | LESS_THAN; LESS_THAN; e = exp; QUESTION; s = SEXP_STRING; GREATER_THAN; GREATER_THAN {DynamicErrorHole(e, s)} *) - (* | b = BUILTIN; {BuiltinFun(b)} *) - (* | UNDEF; {Undefined} *) - (* | u = unExp { u } *) + | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } + | TRUE { Bool true } + | f = funExp {f} + | FALSE { Bool false } + | FIX; p = pat; DASH_ARROW; e = exp { FixF(p, e) } + | TYP_FUN; t = tpat; DASH_ARROW; e = exp {TypFun(t, e)} + | QUESTION { EmptyHole } + | a = filterAction; cond = exp; COMMA; body = exp { Filter(a, cond, body)} + | TEST; e = exp; END { Test(e) } + | e1 = exp; AT_SYMBOL; e2 = exp { ListConcat(e1, e2) } + | e1 = exp; CONS; e2 = exp { Cons(e1, e2) } + | e1 = exp; SEMI_COLON; e2 = exp { Seq(e1, e2) } + | QUESTION; s = STRING; { InvalidExp(s) } + | IN_AP; WILD {Deferral(InAp)} + | OUT_AP; WILD {Deferral(OutsideAp)} + | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} + | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} + | LESS_THAN; LESS_THAN; e = exp; QUESTION; s = SEXP_STRING; GREATER_THAN; GREATER_THAN {DynamicErrorHole(e, s)} + | b = BUILTIN; {BuiltinFun(b)} + | UNDEF; {Undefined} + | u = unExp { u } From 9246a07edc6406fafb945030cfc8c469ad2d1e60 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Fri, 13 Sep 2024 15:41:50 -0400 Subject: [PATCH 047/281] Fixed precedence issues in the menhir parser; tests now run sucessfully --- src/haz3lcore/dynamics/Elaborator.re | 1 - src/haz3lmenhir/Parser.mly | 17 ++++++++--------- test/Test_Elaboration.re | 3 ++- 3 files changed, 10 insertions(+), 11 deletions(-) diff --git a/src/haz3lcore/dynamics/Elaborator.re b/src/haz3lcore/dynamics/Elaborator.re index 54602ffe6f..86b04ed557 100644 --- a/src/haz3lcore/dynamics/Elaborator.re +++ b/src/haz3lcore/dynamics/Elaborator.re @@ -209,7 +209,6 @@ let rec elaborate = (m: Statics.Map.t, uexp: UExp.t): (DHExp.t, Typ.t) => { let (elaborated_type, ctx, co_ctx) = elaborated_type(m, uexp); let cast_from = (ty, exp) => fresh_cast(exp, ty, elaborated_type); let (term, rewrap) = UExp.unwrap(uexp); - print_endline("Elaborating"); let dhexp = switch (term) { diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index c7030fd5af..f6b0a795a6 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -99,15 +99,18 @@ open AST %nonassoc IF_EXP %nonassoc LET_EXP -%left PLUS MINUS TIMES POWER DIVIDE DOUBLE_EQUAL NOT_EQUAL LESS_THAN LESS_THAN_EQUAL GREATER_THAN GREATER_THAN_EQUAL +%left DASH_ARROW + +%left PLUS MINUS TIMES POWER DIVIDE DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL + +%left GREATER_THAN LESS_THAN %left PLUS_FLOAT MINUS_FLOAT TIMES_FLOAT POWER_FLOAT DIVIDE_FLOAT DOUBLE_EQUAL_FLOAT NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT (* Other *) -%left DASH_ARROW %left CONS %left OPEN_PAREN -%right QUESTION +%left QUESTION %left COLON %left COMMA %left AT_SYMBOL @@ -179,17 +182,13 @@ typ: | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } | t1 = typ; DASH_ARROW; t2 = typ { ArrowType(t1, t2) } -varPat: - | i = IDENT { VarPat (i) } - - pat: | QUESTION; s = STRING { InvalidPat(s) } | WILD { WildPat } | QUESTION { EmptyHolePat } | OPEN_SQUARE_BRACKET; l = separated_list(COMMA, pat); CLOSE_SQUARE_BRACKET; { ListPat(l) } | c = CONSTRUCTOR_IDENT; COLON; t = typ; { ConstructorPat(c, t) } - | p = varPat {p} + | p = IDENT { VarPat(p) } | t = patTuple { t } | i = INT { IntPat i } | f = FLOAT { FloatPat f } @@ -211,7 +210,7 @@ case: | CASE; e = exp; l = list(rul); END; { CaseExp(e, l) } funExp: - | FUN; p = pat; DASH_ARROW; e1 = exp; { Fun (p, e1, None) } + | FUN; p = pat; DASH_ARROW; e1 = exp; { Fun (p, e1, None) } | FUN; p = pat; DASH_ARROW; e1 = exp; name = IDENT { Fun (p, e1, Some(name)) } diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 615a36bdb2..860e5ae787 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -49,6 +49,7 @@ let f = f in 55"; + let let_fun_menhir = () => alco_check_menhir( "Let expression for a function which is not recursive (menhir)", @@ -276,7 +277,7 @@ let test_uexp: Exp.t = { let test_menhir = () => alco_check_menhir("Test failed (menhir)", test_str, test_uexp); -let filter_str = "eval 1 0"; +let filter_str = "eval 1, 0"; let stepper_filter_kind = TermBase.StepperFilterKind.Filter({ pat: Int(1) |> Exp.fresh, From cf736fab51d8d7ed0f8810a50deb0c86846b45fb Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Tue, 1 Oct 2024 20:57:04 -0400 Subject: [PATCH 048/281] Added some more menhir-based elaboration tests --- src/haz3lcore/statics/TermBase.re | 2 +- src/haz3lmenhir/AST.re | 3 +- src/haz3lmenhir/Conversion.re | 37 ++++++++++------ src/haz3lmenhir/Lexer.mll | 2 - src/haz3lmenhir/Parser.mly | 6 +-- test/Test_Elaboration.re | 70 +++++++++++++++++++++++++++++++ test/Test_Menhir.re | 5 +++ 7 files changed, 102 insertions(+), 23 deletions(-) diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index fed024f04a..4fa25a2227 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -162,7 +162,7 @@ and Exp: { | TyAlias(TPat.t, Typ.t, t) //type tp = ty in e | Ap(Operators.ap_direction, t, t) //e1(e2) | TypAp(t, Typ.t) /*e @ */ - | DeferredAp(t, list(t)) //e1(_e2) + | DeferredAp(t, list(t)) //e1(e2, _, e3) | If(t, t, t) //if e1 then e2 else e3 | Seq(t, t) //e1;e2 | Test(t) //test e end diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 69fa7dc876..d1b9b230a5 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -138,13 +138,12 @@ type exp = | Undefined | Seq(exp, exp) | Test(exp) - | Deferral(deferral_pos) + | Deferral | TypFun(tpat, exp) | Cons(exp, exp) | ListConcat(exp, exp) | If(exp, exp, exp) | InvalidExp(string) | TypAp(exp, typ) - | DeferredAp(exp) | DynamicErrorHole(exp, string) | TyAlias(tpat, typ, exp); diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 9ff78b0390..b29bd8fc40 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -1,5 +1,4 @@ include Sexplib.Std; - module FilterAction = { open Haz3lcore.FilterAction; let of_menhir_ast = (a: AST.filter_action): t => { @@ -106,11 +105,11 @@ module rec Exp: { | Bool(b) => Bool(b) | Var(x) => Var(x) | Constructor(x, ty) => Constructor(x, Typ.of_menhir_ast(ty)) - | Deferral(pos) => - switch (pos) { - | InAp => Deferral(InAp) - | OutsideAp => Deferral(OutsideAp) - } + | Deferral => Deferral(InAp) + // switch (pos) { + // | InAp => Deferral(InAp) + // | OutsideAp => Deferral(OutsideAp) + // } | ListExp(l) => ListLit(List.map(of_menhir_ast, l)) | TupleExp(t) => if (List.length(t) == 1) { @@ -130,11 +129,6 @@ module rec Exp: { of_menhir_ast(e), ) | BuiltinFun(s) => BuiltinFun(s) - | DeferredAp(f) => - switch (f) { - | ApExp(fn, a) => DeferredAp(of_menhir_ast(fn), [of_menhir_ast(a)]) - | _ => raise(Invalid_argument("Expected ApExp")) - } | Fun(p, e, name_opt) => switch (name_opt) { | Some(name_str) => @@ -146,8 +140,25 @@ module rec Exp: { ) | None => Fun(Pat.of_menhir_ast(p), of_menhir_ast(e), None, None) } - | ApExp(e1, e2) => - Ap(Haz3lcore.Operators.Forward, of_menhir_ast(e1), of_menhir_ast(e2)) + | ApExp(e1, args) => + switch (args) { + | TupleExp(l) => + List.mem(AST.Deferral, l) + ? DeferredAp(of_menhir_ast(e1), List.map(of_menhir_ast, l)) + : Ap( + Haz3lcore.Operators.Forward, + of_menhir_ast(e1), + of_menhir_ast(args), + ) + | Deferral => DeferredAp(of_menhir_ast(e1), [args |> of_menhir_ast]) + + | _ => + Ap( + Haz3lcore.Operators.Forward, + of_menhir_ast(e1), + of_menhir_ast(args), + ) + } | BinExp(e1, op, e2) => BinOp( Operators.of_menhir_ast(op), diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index e59b72f3da..8fd6175e0b 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -105,8 +105,6 @@ rule token = | "?" {QUESTION} | "_" {WILD} | "fix" {FIX} - | "_InAp" {IN_AP} - | "_OutAp" {OUT_AP} | "typfun" {TYP_FUN} | "type" {TYP} | "$" {DOLLAR_SIGN} diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index f6b0a795a6..67bb0e6dee 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -10,8 +10,6 @@ open AST %token DOLLAR_SIGN %token TYP %token TYP_FUN -%token IN_AP -%token OUT_AP %token FIX %token WILD %token QUESTION @@ -246,7 +244,6 @@ exp: | c = case { c } | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ListExp(e) } | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } - | f = exp; OPEN_PAREN; WILD; a = exp; CLOSE_PAREN { DeferredAp(ApExp(f, a)) } | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } %prec LET_EXP | i = ifExp { i } | e1 = exp; QUESTION; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN {FailedCast(e1, t1, t2)} @@ -263,8 +260,7 @@ exp: | e1 = exp; CONS; e2 = exp { Cons(e1, e2) } | e1 = exp; SEMI_COLON; e2 = exp { Seq(e1, e2) } | QUESTION; s = STRING; { InvalidExp(s) } - | IN_AP; WILD {Deferral(InAp)} - | OUT_AP; WILD {Deferral(OutsideAp)} + | WILD {Deferral} | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} | LESS_THAN; LESS_THAN; e = exp; QUESTION; s = SEXP_STRING; GREATER_THAN; GREATER_THAN {DynamicErrorHole(e, s)} diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 860e5ae787..fe7a3404f4 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -291,6 +291,70 @@ let filter_uexp: Exp.t = { let filter_menhir = () => alco_check_menhir("Filter test (menhir)", filter_str, filter_uexp); +//NOTE: left out until deferral elaborations are fixed +// let deferred_str = " +// (fun x -> 4 + 5)(_) +// "; +// let deferred_uexp: Exp.t = +// DeferredAp( +// Fun( +// Var("x") |> Pat.fresh, +// BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) +// |> Exp.fresh, +// None, +// None, +// ) +// |> Exp.fresh, +// [Deferral(InAp) |> Exp.fresh], +// ) +// |> Exp.fresh; +// let deferred_ap_menhir = () => +// alco_check_menhir("Deferred Ap Test (menhir)", deferred_str, deferred_uexp); + +let undefined_str = " +undef +"; +let undefined_uexp: Exp.t = Undefined |> Exp.fresh; +let undefined_menhir = () => + alco_check_menhir("Undefined test (menhir)", undefined_str, undefined_uexp); + +let list_exp_str = "[1, 2, 3]"; +let list_exp_uexp: Exp.t = { + ids: [id_at(0)], + term: + ListLit([ + Int(1) |> Exp.fresh, + Int(2) |> Exp.fresh, + Int(3) |> Exp.fresh, + ]), + copied: false, +}; +let list_exp_menhir = () => + alco_check_menhir("List exp (menhir)", list_exp_str, list_exp_uexp); + +let invalid_str = " +?\"x\" +"; +let invalid_uexp: Exp.t = Invalid("x") |> Exp.fresh; +let invalid_menhir = () => + alco_check_menhir("Invalid test (menhir)", invalid_str, invalid_uexp); + +let ty_alias_str = " +x +"; +let ty_alias_uexp: Exp.t = { + ids: [id_at(0)], + term: + TyAlias( + Var("x") |> TPat.fresh, + Int |> Typ.fresh, + Var("x") |> Exp.fresh, + ), + copied: false, +}; +let ty_alias_menhir = () => + alco_check_menhir("Type alias test (menhir)", ty_alias_str, ty_alias_uexp); + let elaboration_tests = [ test_case("Filter test (menhir)", `Quick, filter_menhir), test_case("Test failed (menhir)", `Quick, test_menhir), @@ -308,4 +372,10 @@ let elaboration_tests = [ test_case("Inconsistent case (menhir)", `Quick, inconsistent_case_menhir), test_case("ap fun (menhir)", `Quick, ap_fun_menhir), test_case("Consistent if (menhir)", `Quick, consistent_if_menhir), + //NOTE: left out until deferral elaborations are fixed + // test_case("Deffered Ap Test (menhir)", `Quick, deferred_ap_menhir), + test_case("Undefined test (menhir)", `Quick, undefined_menhir), + test_case("List exp (menhir)", `Quick, list_exp_menhir), + test_case("Invalid test (menhir)", `Quick, invalid_menhir), + test_case("Type alias test (menhir)", `Quick, ty_alias_menhir), ]; diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 168b76d34c..4859f381e0 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -27,4 +27,9 @@ let tests = [ `Quick, parser_test("Same String", String("Hello World"), "\"Hello World\""), ), + test_case( + "Deferred Ap", + `Quick, + parser_test("Deferred Ap", AST.ApExp(Var("x"), Deferral), "x(_)"), + ), ]; From b7481c79162c575ee67c1f4643362d69449474ea Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Tue, 1 Oct 2024 21:06:12 -0400 Subject: [PATCH 049/281] Added menhir elaboration tests for list concat, minus unop & fixed menhir int parsing bug --- src/haz3lmenhir/Lexer.mll | 3 ++- test/Test_Elaboration.re | 28 ++++++++++++++++++++++++++++ 2 files changed, 30 insertions(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index 8fd6175e0b..ba54cb6c03 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -24,6 +24,7 @@ let whitespace = [' ' '\t']+ let identifier = ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* let constructor_ident = ['A'-'Z'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* let sexp_string = '`' [^'`']* '`' +let ints = ['0'-'9']+ rule token = parse @@ -31,7 +32,7 @@ rule token = | "infinity" | "neg_infinity" | "nan" | "epsilon_float" | "pi" | "max_int" | "min_int" | "is_finite" | "is_infinite" | "int_of_float" | "float_of_int" | "string_of_int" | "string_of_float" | "string_of_bool" | "int_of_string" | "float_of_string" | "bool_of_string" | "abs" | "abs_float" | "ceil" | "floor" | "exp" | "log" | "log10" | "sqrt" | "sin" | "cos" | "tan" | "asin" | "acos" | "atan" | "mod" | "string_length" | "string_compare" | "string_trim" | "string_concat" | "string_sub" { BUILTIN(Lexing.lexeme lexbuf)} | whitespace {token lexbuf } | newline { advance_line lexbuf; token lexbuf} - | int as i { INT (int_of_string i) } + | ints as i { INT (int_of_string i) } | float as f { FLOAT (float_of_string f )} | string as s { STRING (String.sub s 1 (String.length s - 2)) } | sexp_string as s { SEXP_STRING (String.sub s 1 (String.length s - 2)) } diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index fe7a3404f4..8cfc7b50c1 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -355,6 +355,32 @@ let ty_alias_uexp: Exp.t = { let ty_alias_menhir = () => alco_check_menhir("Type alias test (menhir)", ty_alias_str, ty_alias_uexp); +let list_concat_str = "[1, 2] @ [3, 4]"; +let list_concat_uexp: Exp.t = { + ids: [id_at(0)], + term: + ListConcat( + ListLit([Int(1) |> Exp.fresh, Int(2) |> Exp.fresh]) |> Exp.fresh, + ListLit([Int(3) |> Exp.fresh, Int(4) |> Exp.fresh]) |> Exp.fresh, + ), + copied: false, +}; +let list_concat_menhir = () => + alco_check_menhir( + "List concat test (menhir)", + list_concat_str, + list_concat_uexp, + ); + +let unop_str = "-1"; +let unop_uexp: Exp.t = { + ids: [id_at(0)], + term: UnOp(Int(Minus), Int(1) |> Exp.fresh), + copied: false, +}; +let unop_menhir = () => + alco_check_menhir("Unary operation test (menhir)", unop_str, unop_uexp); + let elaboration_tests = [ test_case("Filter test (menhir)", `Quick, filter_menhir), test_case("Test failed (menhir)", `Quick, test_menhir), @@ -378,4 +404,6 @@ let elaboration_tests = [ test_case("List exp (menhir)", `Quick, list_exp_menhir), test_case("Invalid test (menhir)", `Quick, invalid_menhir), test_case("Type alias test (menhir)", `Quick, ty_alias_menhir), + test_case("List concat test (menhir)", `Quick, list_concat_menhir), + test_case("Unary operation test (menhir)", `Quick, unop_menhir), ]; From cf7b720ded531ea070c834e3e07ac4cab2986b54 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Tue, 1 Oct 2024 21:12:44 -0400 Subject: [PATCH 050/281] Added menhir elaboration test for seq, fixf --- src/haz3lcore/statics/TermBase.re | 6 +++--- test/Test_Elaboration.re | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+), 3 deletions(-) diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index 4fa25a2227..19ceb71d06 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -137,7 +137,7 @@ and Exp: { type term = | Invalid(string) //? s | EmptyHole //? - | MultiHole(list(Any.t)) //<> + | MultiHole(list(Any.t)) | DynamicErrorHole(t, InvalidOperationError.t) //This exp takes in the Sexp serialization of the InvalidOperationError.t as a string (s); // <> | FailedCast(t, Typ.t, Typ.t) //e ? ty2> | Deferral(deferral_position) /*InAp _*/ /*OutAp _*/ @@ -164,7 +164,7 @@ and Exp: { | TypAp(t, Typ.t) /*e @ */ | DeferredAp(t, list(t)) //e1(e2, _, e3) | If(t, t, t) //if e1 then e2 else e3 - | Seq(t, t) //e1;e2 + | Seq(t, t) //e1; e2 | Test(t) //test e end | Filter(StepperFilterKind.t, t) /*let act represent filter action*/ //act e1 e2 | Closure([@show.opaque] ClosureEnvironment.t, t) // menhir - spoke with cyrus we don't need closures in the menhir @@ -173,7 +173,7 @@ and Exp: { | ListConcat(t, t) //e1 @ e2 | UnOp(Operators.op_un, t) //!e -e $e | BinOp(Operators.op_bin, t, t) //e1 + e2 - | BuiltinFun(string) //TODO menhir + | BuiltinFun(string) //builtin(e1) | Match(t, list((Pat.t, t))) /* case e1 diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 8cfc7b50c1..7ecb567ff4 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -381,6 +381,24 @@ let unop_uexp: Exp.t = { let unop_menhir = () => alco_check_menhir("Unary operation test (menhir)", unop_str, unop_uexp); +let seq_str = "1; 2"; +let seq_uexp: Exp.t = { + ids: [id_at(0)], + term: Seq(Int(1) |> Exp.fresh, Int(2) |> Exp.fresh), + copied: false, +}; +let seq_menhir = () => + alco_check_menhir("Sequence test (menhir)", seq_str, seq_uexp); + +let fixf_str = "fix x -> 1 Unknown Internal>"; +let fixf_uexp: Exp.t = { + ids: [id_at(0)], + term: FixF(Var("x") |> Pat.fresh, Int(1) |> Exp.fresh, None), + copied: false, +}; +let fixf_menhir = () => + alco_check_menhir("FixF test (menhir)", fixf_str, fixf_uexp); + let elaboration_tests = [ test_case("Filter test (menhir)", `Quick, filter_menhir), test_case("Test failed (menhir)", `Quick, test_menhir), @@ -406,4 +424,6 @@ let elaboration_tests = [ test_case("Type alias test (menhir)", `Quick, ty_alias_menhir), test_case("List concat test (menhir)", `Quick, list_concat_menhir), test_case("Unary operation test (menhir)", `Quick, unop_menhir), + test_case("Sequence test (menhir)", `Quick, seq_menhir), + test_case("FixF test (menhir)", `Quick, fixf_menhir), ]; From 079754ba9840f8a4e8489cadfd84bcf080cc7249 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Wed, 2 Oct 2024 12:50:29 -0400 Subject: [PATCH 051/281] Fixing issue with dev -> menhir tests merge --- test/Test_Elaboration.re | 4 ---- 1 file changed, 4 deletions(-) diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index ecc03fba92..65ce5b352f 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -137,10 +137,6 @@ let ap_fun_uexp: Exp.t = Var("y") |> Exp.fresh, ) |> Exp.fresh; -let unapplied_function = () => alco_check("A function", f, dhexp_of_uexp(f)); - -let u7: Exp.t = Ap(Forward, f, Var("y") |> Exp.fresh) |> Exp.fresh; - let ap_fun_str = " (fun x -> 4 + 5)(y) "; From 4c4eeb90af646e91bd7bff9fd62b546f5e702aeb Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sun, 6 Oct 2024 15:32:57 -0400 Subject: [PATCH 052/281] Removed some menhir elaboration test debug code --- src/haz3lcore/dynamics/Elaborator.re | 1 - src/haz3lmenhir/Conversion.re | 7 +------ 2 files changed, 1 insertion(+), 7 deletions(-) diff --git a/src/haz3lcore/dynamics/Elaborator.re b/src/haz3lcore/dynamics/Elaborator.re index 86b04ed557..bf269861db 100644 --- a/src/haz3lcore/dynamics/Elaborator.re +++ b/src/haz3lcore/dynamics/Elaborator.re @@ -573,6 +573,5 @@ let uexp_elab = (m: Statics.Map.t, uexp: UExp.t): ElaborationResult.t => switch (elaborate(m, uexp)) { | exception MissingTypeInfo => DoesNotElaborate | (d, ty) => - print_endline("Elaborated: " ++ DHExp.show(d)); Elaborates(d, ty, Delta.empty); }; diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index b29bd8fc40..18c39bdb56 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -132,12 +132,7 @@ module rec Exp: { | Fun(p, e, name_opt) => switch (name_opt) { | Some(name_str) => - Fun( - Pat.of_menhir_ast(p), - of_menhir_ast(e), - None, - Some(name_str ++ "+"), - ) + Fun(Pat.of_menhir_ast(p), of_menhir_ast(e), None, Some(name_str)) | None => Fun(Pat.of_menhir_ast(p), of_menhir_ast(e), None, None) } | ApExp(e1, args) => From 850d247089f588f15616532be78b3d712984595e Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 6 Oct 2024 17:58:57 -0400 Subject: [PATCH 053/281] Fix formatting --- src/haz3lcore/dynamics/Elaborator.re | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/haz3lcore/dynamics/Elaborator.re b/src/haz3lcore/dynamics/Elaborator.re index bf269861db..3b5812c016 100644 --- a/src/haz3lcore/dynamics/Elaborator.re +++ b/src/haz3lcore/dynamics/Elaborator.re @@ -572,6 +572,5 @@ let fix_typ_ids = let uexp_elab = (m: Statics.Map.t, uexp: UExp.t): ElaborationResult.t => switch (elaborate(m, uexp)) { | exception MissingTypeInfo => DoesNotElaborate - | (d, ty) => - Elaborates(d, ty, Delta.empty); + | (d, ty) => Elaborates(d, ty, Delta.empty) }; From 935f842520171cab2b37039a0e7245bb2e109985 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 6 Oct 2024 17:59:11 -0400 Subject: [PATCH 054/281] Move menhir elaboration tests into module --- test/Test_Elaboration.re | 784 ++++++++++++++++++++------------------- test/haz3ltest.re | 4 +- 2 files changed, 404 insertions(+), 384 deletions(-) diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 65ce5b352f..9eb2991978 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -12,37 +12,38 @@ let mk_map = Statics.mk(CoreSettings.on, Builtins.ctx_init); let dhexp_of_uexp = u => Elaborator.elaborate(mk_map(u), u) |> fst; let alco_check = dhexp_typ |> Alcotest.check; -let alco_check_menhir = (name: string, dhexp: string, uexp: Term.Exp.t) => - alco_check( - name, - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(dhexp), - ), - dhexp_of_uexp(uexp), - ); - -//Test for a let function -let let_fun_uexp: Exp.t = - Let( - Cast( - Var("f") |> Pat.fresh, - Arrow(Int |> Typ.fresh, Int |> Typ.fresh) |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) - |> Pat.fresh, - Fun( - Var("x") |> Pat.fresh, - BinOp(Int(Plus), Int(1) |> Exp.fresh, Var("x") |> Exp.fresh) +module MenhirElaborationTests = { + let alco_check_menhir = (name: string, dhexp: string, uexp: Term.Exp.t) => + alco_check( + name, + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(dhexp), + ), + dhexp_of_uexp(uexp), + ); + + //Test for a let function + let let_fun_uexp: Exp.t = + Let( + Cast( + Var("f") |> Pat.fresh, + Arrow(Int |> Typ.fresh, Int |> Typ.fresh) |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Pat.fresh, + Fun( + Var("x") |> Pat.fresh, + BinOp(Int(Plus), Int(1) |> Exp.fresh, Var("x") |> Exp.fresh) + |> Exp.fresh, + None, + None, + ) |> Exp.fresh, - None, - None, + Int(55) |> Exp.fresh, ) - |> Exp.fresh, - Int(55) |> Exp.fresh, - ) - |> Exp.fresh; + |> Exp.fresh; -let let_fun_str = " + let let_fun_str = " let f = fun x -> 1 + x @@ -50,379 +51,398 @@ let f = in 55"; -let let_fun_menhir = () => - alco_check_menhir( - "Let expression for a function which is not recursive (menhir)", - let_fun_str, - let_fun_uexp, - ); - -//Test for an empty hole -let empty_hole_str = "?"; -let empty_hole_uexp: Exp.t = { - ids: [id_at(0)], - term: EmptyHole, - copied: false, -}; -let empty_hole_menhir = () => - alco_check_menhir("Empty hole (menhir)", empty_hole_str, empty_hole_uexp); - -//Test for a free variable -let free_var_uexp: Exp.t = { - ids: [id_at(0)], - term: Parens({ids: [id_at(1)], term: Var("y"), copied: false}), - copied: false, -}; -let free_var_menhir = () => - alco_check( - "Nonempty hole with free variable (menhir)", - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program("y"), - ), - dhexp_of_uexp(free_var_uexp), - ); - -//Menhir test for a binary operation -let bin_op_uexp: Exp.t = - BinOp(Int(Plus), Bool(false) |> Exp.fresh, Var("y") |> Exp.fresh) - |> Exp.fresh; - -let bin_op_str = "false? Int> + y Int>"; - -let bin_op_menhir = () => - alco_check( - "Inconsistent binary integer operation (plus)", - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(bin_op_str), - ), - dhexp_of_uexp(bin_op_uexp), - ); - -//Inconsistent branches menhir test -let inconsistent_case_menhir_str = " + let let_fun_menhir = () => + alco_check_menhir( + "Let expression for a function which is not recursive (menhir)", + let_fun_str, + let_fun_uexp, + ); + + //Test for an empty hole + let empty_hole_str = "?"; + let empty_hole_uexp: Exp.t = { + ids: [id_at(0)], + term: EmptyHole, + copied: false, + }; + let empty_hole_menhir = () => + alco_check_menhir("Empty hole (menhir)", empty_hole_str, empty_hole_uexp); + + //Test for a free variable + let free_var_uexp: Exp.t = { + ids: [id_at(0)], + term: Parens({ids: [id_at(1)], term: Var("y"), copied: false}), + copied: false, + }; + let free_var_menhir = () => + alco_check( + "Nonempty hole with free variable (menhir)", + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program("y"), + ), + dhexp_of_uexp(free_var_uexp), + ); + + //Menhir test for a binary operation + let bin_op_uexp: Exp.t = + BinOp(Int(Plus), Bool(false) |> Exp.fresh, Var("y") |> Exp.fresh) + |> Exp.fresh; + + let bin_op_str = "false? Int> + y Int>"; + + let bin_op_menhir = () => + alco_check( + "Inconsistent binary integer operation (plus)", + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(bin_op_str), + ), + dhexp_of_uexp(bin_op_uexp), + ); + + //Inconsistent branches menhir test + let inconsistent_case_menhir_str = " case 4 == 3 | true => 24 Unknown Internal> | false => false Unknown Internal> end "; -let inconsistent_case_uexp: Exp.t = - Match( - BinOp(Int(Equals), Int(4) |> Exp.fresh, Int(3) |> Exp.fresh) - |> Exp.fresh, - [ - (Bool(true) |> Pat.fresh, Int(24) |> Exp.fresh), - (Bool(false) |> Pat.fresh, Bool(false) |> Exp.fresh), - ], - ) - |> Exp.fresh; -let inconsistent_case_menhir = () => - alco_check_menhir( - "Inconsistent branches where the first branch is an integer and second branch is a boolean (menhir)", - inconsistent_case_menhir_str, - inconsistent_case_uexp, - ); - -//Function free var application menhir test -let ap_fun_uexp: Exp.t = - Ap( - Forward, - Fun( - Var("x") |> Pat.fresh, - BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) + let inconsistent_case_uexp: Exp.t = + Match( + BinOp(Int(Equals), Int(4) |> Exp.fresh, Int(3) |> Exp.fresh) + |> Exp.fresh, + [ + (Bool(true) |> Pat.fresh, Int(24) |> Exp.fresh), + (Bool(false) |> Pat.fresh, Bool(false) |> Exp.fresh), + ], + ) + |> Exp.fresh; + let inconsistent_case_menhir = () => + alco_check_menhir( + "Inconsistent branches where the first branch is an integer and second branch is a boolean (menhir)", + inconsistent_case_menhir_str, + inconsistent_case_uexp, + ); + + //Function free var application menhir test + let ap_fun_uexp: Exp.t = + Ap( + Forward, + Fun( + Var("x") |> Pat.fresh, + BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) + |> Exp.fresh, + None, + None, + ) |> Exp.fresh, - None, - None, + Var("y") |> Exp.fresh, ) - |> Exp.fresh, - Var("y") |> Exp.fresh, - ) - |> Exp.fresh; -let ap_fun_str = " + |> Exp.fresh; + let ap_fun_str = " (fun x -> 4 + 5)(y) "; -let ap_fun_menhir = () => - alco_check( - "Application of a function (menhir)", - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(ap_fun_str), - ), - dhexp_of_uexp(ap_fun_uexp), - ); - -//Consistent if statement menhir test -let consistent_if_uexp: Exp.t = - If(Bool(false) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) - |> Exp.fresh; - -let consistent_if_str = " + let ap_fun_menhir = () => + alco_check( + "Application of a function (menhir)", + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(ap_fun_str), + ), + dhexp_of_uexp(ap_fun_uexp), + ); + + //Consistent if statement menhir test + let consistent_if_uexp: Exp.t = + If(Bool(false) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) + |> Exp.fresh; + + let consistent_if_str = " if false then 8 else 6 "; -let consistent_if_menhir = () => - alco_check( - "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(consistent_if_str), - ), - dhexp_of_uexp(consistent_if_uexp), - ); - -//Single integer menhir test -let single_int_str = "8"; -let single_int_uexp: Exp.t = { - ids: [id_at(0)], - term: Int(8), - copied: false, -}; -let single_integer_menhir = () => - alco_check_menhir( - "Single integer test (menhir)", - single_int_str, - single_int_uexp, - ); - -//Menhir let expression test -let let_exp_str = "let (a, b) = (4, 6) in a - b"; -let let_exp_uexp: Exp.t = - Let( - Tuple([Var("a") |> Pat.fresh, Var("b") |> Pat.fresh]) |> Pat.fresh, - Tuple([Int(4) |> Exp.fresh, Int(6) |> Exp.fresh]) |> Exp.fresh, - BinOp(Int(Minus), Var("a") |> Exp.fresh, Var("b") |> Exp.fresh) - |> Exp.fresh, - ) - |> Exp.fresh; -let let_exp_menhir = () => - alco_check_menhir( - "Let expression for tuple (a, b) (menhir)", - let_exp_str, - let_exp_uexp, - ); - -let typ_ap_str = "(typfun x -> 4) @ "; -let typ_ap_uexp: Exp.t = - TypAp( - TypFun(Var("x") |> TPat.fresh, Int(4) |> Exp.fresh, None) |> Exp.fresh, - Int |> Typ.fresh, - ) - |> Exp.fresh; -let typ_ap_menhir = () => - alco_check_menhir("Type ap test (menhir)", typ_ap_str, typ_ap_uexp); - -let failed_cast_str = "1 ? String>"; -let failed_cast_uexp: Exp.t = - FailedCast(Int(1) |> Exp.fresh, Int |> Typ.fresh, String |> Typ.fresh) - |> Exp.fresh; -let failed_cast_menhir = () => - alco_check_menhir( - "Failed cast test (menhir)", - failed_cast_str, - failed_cast_uexp, - ); - -let constructor_str = "X: Unknown Internal"; -let constructor_uexp: Exp.t = - Constructor("X", Unknown(Internal) |> Typ.fresh) |> Exp.fresh; -let constructor_menhir = () => - alco_check_menhir( - "Constructor test (menhir)", - constructor_str, - constructor_uexp, - ); - -/* - <<1 / 2 ? `a`>> - */ -let dynamic_error_hole_str = "<<(1/0) ? `DivideByZero`>> Int>"; -let dynamic_error_hole_uexp: Exp.t = { - ids: [id_at(0)], - term: - DynamicErrorHole( - BinOp(Int(Divide), Int(1) |> Exp.fresh, Int(0) |> Exp.fresh) + let consistent_if_menhir = () => + alco_check( + "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(consistent_if_str), + ), + dhexp_of_uexp(consistent_if_uexp), + ); + + //Single integer menhir test + let single_int_str = "8"; + let single_int_uexp: Exp.t = { + ids: [id_at(0)], + term: Int(8), + copied: false, + }; + let single_integer_menhir = () => + alco_check_menhir( + "Single integer test (menhir)", + single_int_str, + single_int_uexp, + ); + + //Menhir let expression test + let let_exp_str = "let (a, b) = (4, 6) in a - b"; + let let_exp_uexp: Exp.t = + Let( + Tuple([Var("a") |> Pat.fresh, Var("b") |> Pat.fresh]) |> Pat.fresh, + Tuple([Int(4) |> Exp.fresh, Int(6) |> Exp.fresh]) |> Exp.fresh, + BinOp(Int(Minus), Var("a") |> Exp.fresh, Var("b") |> Exp.fresh) |> Exp.fresh, - InvalidOperationError.DivideByZero, - ), - copied: false, -}; -let dynamic_error_hole_menhir = () => - alco_check_menhir( - "Dynamic error hole (menhir)", - dynamic_error_hole_str, - dynamic_error_hole_uexp, - ); - -let builtin_fun_str = "infinity"; -let builtin_fun_uexp: Exp.t = { - ids: [id_at(0)], - term: BuiltinFun("infinity"), - copied: false, -}; -let builtin_fun_menhir = () => - alco_check_menhir( - "Builtin function test (menhir)", - builtin_fun_str, - builtin_fun_uexp, - ); - -let undef_str = "undef"; -let undef_uexp: Exp.t = {ids: [id_at(0)], term: Undefined, copied: false}; -let undef_menhir = () => - alco_check_menhir("Undef test (menhir)", undef_str, undef_uexp); - -let test_str = "test 1 ? Bool> end"; -let test_uexp: Exp.t = { - ids: [id_at(0)], - term: Test(Int(1) |> Exp.fresh), - copied: false, -}; -let test_menhir = () => - alco_check_menhir("Test failed (menhir)", test_str, test_uexp); - -let filter_str = "eval 1, 0"; -let stepper_filter_kind = - TermBase.StepperFilterKind.Filter({ - pat: Int(1) |> Exp.fresh, - act: (FilterAction.Eval, FilterAction.All), - }); -let filter_uexp: Exp.t = { - ids: [id_at(0)], - term: Filter(stepper_filter_kind, Int(0) |> Exp.fresh), - copied: false, -}; -let filter_menhir = () => - alco_check_menhir("Filter test (menhir)", filter_str, filter_uexp); - -//NOTE: left out until deferral elaborations are fixed -// let deferred_str = " -// (fun x -> 4 + 5)(_) -// "; -// let deferred_uexp: Exp.t = -// DeferredAp( -// Fun( -// Var("x") |> Pat.fresh, -// BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) -// |> Exp.fresh, -// None, -// None, -// ) -// |> Exp.fresh, -// [Deferral(InAp) |> Exp.fresh], -// ) -// |> Exp.fresh; -// let deferred_ap_menhir = () => -// alco_check_menhir("Deferred Ap Test (menhir)", deferred_str, deferred_uexp); - -let undefined_str = " + ) + |> Exp.fresh; + let let_exp_menhir = () => + alco_check_menhir( + "Let expression for tuple (a, b) (menhir)", + let_exp_str, + let_exp_uexp, + ); + + let typ_ap_str = "(typfun x -> 4) @ "; + let typ_ap_uexp: Exp.t = + TypAp( + TypFun(Var("x") |> TPat.fresh, Int(4) |> Exp.fresh, None) |> Exp.fresh, + Int |> Typ.fresh, + ) + |> Exp.fresh; + let typ_ap_menhir = () => + alco_check_menhir("Type ap test (menhir)", typ_ap_str, typ_ap_uexp); + + let failed_cast_str = "1 ? String>"; + let failed_cast_uexp: Exp.t = + FailedCast(Int(1) |> Exp.fresh, Int |> Typ.fresh, String |> Typ.fresh) + |> Exp.fresh; + let failed_cast_menhir = () => + alco_check_menhir( + "Failed cast test (menhir)", + failed_cast_str, + failed_cast_uexp, + ); + + let constructor_str = "X: Unknown Internal"; + let constructor_uexp: Exp.t = + Constructor("X", Unknown(Internal) |> Typ.fresh) |> Exp.fresh; + let constructor_menhir = () => + alco_check_menhir( + "Constructor test (menhir)", + constructor_str, + constructor_uexp, + ); + + /* + <<1 / 2 ? `a`>> + */ + let dynamic_error_hole_str = "<<(1/0) ? `DivideByZero`>> Int>"; + let dynamic_error_hole_uexp: Exp.t = { + ids: [id_at(0)], + term: + DynamicErrorHole( + BinOp(Int(Divide), Int(1) |> Exp.fresh, Int(0) |> Exp.fresh) + |> Exp.fresh, + InvalidOperationError.DivideByZero, + ), + copied: false, + }; + let dynamic_error_hole_menhir = () => + alco_check_menhir( + "Dynamic error hole (menhir)", + dynamic_error_hole_str, + dynamic_error_hole_uexp, + ); + + let builtin_fun_str = "infinity"; + let builtin_fun_uexp: Exp.t = { + ids: [id_at(0)], + term: BuiltinFun("infinity"), + copied: false, + }; + let builtin_fun_menhir = () => + alco_check_menhir( + "Builtin function test (menhir)", + builtin_fun_str, + builtin_fun_uexp, + ); + + let undef_str = "undef"; + let undef_uexp: Exp.t = {ids: [id_at(0)], term: Undefined, copied: false}; + let undef_menhir = () => + alco_check_menhir("Undef test (menhir)", undef_str, undef_uexp); + + let test_str = "test 1 ? Bool> end"; + let test_uexp: Exp.t = { + ids: [id_at(0)], + term: Test(Int(1) |> Exp.fresh), + copied: false, + }; + let test_menhir = () => + alco_check_menhir("Test failed (menhir)", test_str, test_uexp); + + let filter_str = "eval 1, 0"; + let stepper_filter_kind = + TermBase.StepperFilterKind.Filter({ + pat: Int(1) |> Exp.fresh, + act: (FilterAction.Eval, FilterAction.All), + }); + let filter_uexp: Exp.t = { + ids: [id_at(0)], + term: Filter(stepper_filter_kind, Int(0) |> Exp.fresh), + copied: false, + }; + let filter_menhir = () => + alco_check_menhir("Filter test (menhir)", filter_str, filter_uexp); + + //NOTE: left out until deferral elaborations are fixed + // let deferred_str = " + // (fun x -> 4 + 5)(_) + // "; + // let deferred_uexp: Exp.t = + // DeferredAp( + // Fun( + // Var("x") |> Pat.fresh, + // BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) + // |> Exp.fresh, + // None, + // None, + // ) + // |> Exp.fresh, + // [Deferral(InAp) |> Exp.fresh], + // ) + // |> Exp.fresh; + // let deferred_ap_menhir = () => + // alco_check_menhir("Deferred Ap Test (menhir)", deferred_str, deferred_uexp); + + let undefined_str = " undef "; -let undefined_uexp: Exp.t = Undefined |> Exp.fresh; -let undefined_menhir = () => - alco_check_menhir("Undefined test (menhir)", undefined_str, undefined_uexp); - -let list_exp_str = "[1, 2, 3]"; -let list_exp_uexp: Exp.t = { - ids: [id_at(0)], - term: - ListLit([ - Int(1) |> Exp.fresh, - Int(2) |> Exp.fresh, - Int(3) |> Exp.fresh, - ]), - copied: false, -}; -let list_exp_menhir = () => - alco_check_menhir("List exp (menhir)", list_exp_str, list_exp_uexp); - -let invalid_str = " + let undefined_uexp: Exp.t = Undefined |> Exp.fresh; + let undefined_menhir = () => + alco_check_menhir( + "Undefined test (menhir)", + undefined_str, + undefined_uexp, + ); + + let list_exp_str = "[1, 2, 3]"; + let list_exp_uexp: Exp.t = { + ids: [id_at(0)], + term: + ListLit([ + Int(1) |> Exp.fresh, + Int(2) |> Exp.fresh, + Int(3) |> Exp.fresh, + ]), + copied: false, + }; + let list_exp_menhir = () => + alco_check_menhir("List exp (menhir)", list_exp_str, list_exp_uexp); + + let invalid_str = " ?\"x\" "; -let invalid_uexp: Exp.t = Invalid("x") |> Exp.fresh; -let invalid_menhir = () => - alco_check_menhir("Invalid test (menhir)", invalid_str, invalid_uexp); + let invalid_uexp: Exp.t = Invalid("x") |> Exp.fresh; + let invalid_menhir = () => + alco_check_menhir("Invalid test (menhir)", invalid_str, invalid_uexp); -let ty_alias_str = " + let ty_alias_str = " x "; -let ty_alias_uexp: Exp.t = { - ids: [id_at(0)], - term: - TyAlias( - Var("x") |> TPat.fresh, - Int |> Typ.fresh, - Var("x") |> Exp.fresh, + let ty_alias_uexp: Exp.t = { + ids: [id_at(0)], + term: + TyAlias( + Var("x") |> TPat.fresh, + Int |> Typ.fresh, + Var("x") |> Exp.fresh, + ), + copied: false, + }; + let ty_alias_menhir = () => + alco_check_menhir( + "Type alias test (menhir)", + ty_alias_str, + ty_alias_uexp, + ); + + let list_concat_str = "[1, 2] @ [3, 4]"; + let list_concat_uexp: Exp.t = { + ids: [id_at(0)], + term: + ListConcat( + ListLit([Int(1) |> Exp.fresh, Int(2) |> Exp.fresh]) |> Exp.fresh, + ListLit([Int(3) |> Exp.fresh, Int(4) |> Exp.fresh]) |> Exp.fresh, + ), + copied: false, + }; + let list_concat_menhir = () => + alco_check_menhir( + "List concat test (menhir)", + list_concat_str, + list_concat_uexp, + ); + + let unop_str = "-1"; + let unop_uexp: Exp.t = { + ids: [id_at(0)], + term: UnOp(Int(Minus), Int(1) |> Exp.fresh), + copied: false, + }; + let unop_menhir = () => + alco_check_menhir("Unary operation test (menhir)", unop_str, unop_uexp); + + let seq_str = "1; 2"; + let seq_uexp: Exp.t = { + ids: [id_at(0)], + term: Seq(Int(1) |> Exp.fresh, Int(2) |> Exp.fresh), + copied: false, + }; + let seq_menhir = () => + alco_check_menhir("Sequence test (menhir)", seq_str, seq_uexp); + + let fixf_str = "fix x -> 1 Unknown Internal>"; + let fixf_uexp: Exp.t = { + ids: [id_at(0)], + term: FixF(Var("x") |> Pat.fresh, Int(1) |> Exp.fresh, None), + copied: false, + }; + let fixf_menhir = () => + alco_check_menhir("FixF test (menhir)", fixf_str, fixf_uexp); + + let tests = [ + test_case("Filter test (menhir)", `Quick, filter_menhir), + test_case("Test failed (menhir)", `Quick, test_menhir), + test_case("Built-in function (menhir)", `Quick, builtin_fun_menhir), + test_case( + "Dynamic error hole (menhir)", + `Quick, + dynamic_error_hole_menhir, ), - copied: false, -}; -let ty_alias_menhir = () => - alco_check_menhir("Type alias test (menhir)", ty_alias_str, ty_alias_uexp); - -let list_concat_str = "[1, 2] @ [3, 4]"; -let list_concat_uexp: Exp.t = { - ids: [id_at(0)], - term: - ListConcat( - ListLit([Int(1) |> Exp.fresh, Int(2) |> Exp.fresh]) |> Exp.fresh, - ListLit([Int(3) |> Exp.fresh, Int(4) |> Exp.fresh]) |> Exp.fresh, + test_case("Constructor test (menhir)", `Quick, constructor_menhir), + test_case("Failed cast test (menhir)", `Quick, failed_cast_menhir), + test_case("Type ap test (menhir)", `Quick, typ_ap_menhir), + test_case("Let expression for a tuple (menhir)", `Quick, let_exp_menhir), + test_case("Single integer (menhir)", `Quick, single_integer_menhir), + test_case( + "Let expression for a function (menhir)", + `Quick, + let_fun_menhir, ), - copied: false, -}; -let list_concat_menhir = () => - alco_check_menhir( - "List concat test (menhir)", - list_concat_str, - list_concat_uexp, - ); - -let unop_str = "-1"; -let unop_uexp: Exp.t = { - ids: [id_at(0)], - term: UnOp(Int(Minus), Int(1) |> Exp.fresh), - copied: false, + test_case("Empty hole (menhir)", `Quick, empty_hole_menhir), + test_case("Free var (menhir)", `Quick, free_var_menhir), + test_case("Bin op (menhir)", `Quick, bin_op_menhir), + test_case("Inconsistent case (menhir)", `Quick, inconsistent_case_menhir), + test_case("ap fun (menhir)", `Quick, ap_fun_menhir), + test_case("Consistent if (menhir)", `Quick, consistent_if_menhir), + //NOTE: left out until deferral elaborations are fixed + // test_case("Deffered Ap Test (menhir)", `Quick, deferred_ap_menhir), + test_case("Undefined test (menhir)", `Quick, undefined_menhir), + test_case("List exp (menhir)", `Quick, list_exp_menhir), + test_case("Invalid test (menhir)", `Quick, invalid_menhir), + test_case("Type alias test (menhir)", `Quick, ty_alias_menhir), + test_case("List concat test (menhir)", `Quick, list_concat_menhir), + test_case("Unary operation test (menhir)", `Quick, unop_menhir), + test_case("Sequence test (menhir)", `Quick, seq_menhir), + test_case("FixF test (menhir)", `Quick, fixf_menhir), + ]; }; -let unop_menhir = () => - alco_check_menhir("Unary operation test (menhir)", unop_str, unop_uexp); - -let seq_str = "1; 2"; -let seq_uexp: Exp.t = { - ids: [id_at(0)], - term: Seq(Int(1) |> Exp.fresh, Int(2) |> Exp.fresh), - copied: false, -}; -let seq_menhir = () => - alco_check_menhir("Sequence test (menhir)", seq_str, seq_uexp); - -let fixf_str = "fix x -> 1 Unknown Internal>"; -let fixf_uexp: Exp.t = { - ids: [id_at(0)], - term: FixF(Var("x") |> Pat.fresh, Int(1) |> Exp.fresh, None), - copied: false, -}; -let fixf_menhir = () => - alco_check_menhir("FixF test (menhir)", fixf_str, fixf_uexp); - -let elaboration_tests = [ - test_case("Filter test (menhir)", `Quick, filter_menhir), - test_case("Test failed (menhir)", `Quick, test_menhir), - test_case("Built-in function (menhir)", `Quick, builtin_fun_menhir), - test_case("Dynamic error hole (menhir)", `Quick, dynamic_error_hole_menhir), - test_case("Constructor test (menhir)", `Quick, constructor_menhir), - test_case("Failed cast test (menhir)", `Quick, failed_cast_menhir), - test_case("Type ap test (menhir)", `Quick, typ_ap_menhir), - test_case("Let expression for a tuple (menhir)", `Quick, let_exp_menhir), - test_case("Single integer (menhir)", `Quick, single_integer_menhir), - test_case("Let expression for a function (menhir)", `Quick, let_fun_menhir), - test_case("Empty hole (menhir)", `Quick, empty_hole_menhir), - test_case("Free var (menhir)", `Quick, free_var_menhir), - test_case("Bin op (menhir)", `Quick, bin_op_menhir), - test_case("Inconsistent case (menhir)", `Quick, inconsistent_case_menhir), - test_case("ap fun (menhir)", `Quick, ap_fun_menhir), - test_case("Consistent if (menhir)", `Quick, consistent_if_menhir), - //NOTE: left out until deferral elaborations are fixed - // test_case("Deffered Ap Test (menhir)", `Quick, deferred_ap_menhir), - test_case("Undefined test (menhir)", `Quick, undefined_menhir), - test_case("List exp (menhir)", `Quick, list_exp_menhir), - test_case("Invalid test (menhir)", `Quick, invalid_menhir), - test_case("Type alias test (menhir)", `Quick, ty_alias_menhir), - test_case("List concat test (menhir)", `Quick, list_concat_menhir), - test_case("Unary operation test (menhir)", `Quick, unop_menhir), - test_case("Sequence test (menhir)", `Quick, seq_menhir), - test_case("FixF test (menhir)", `Quick, fixf_menhir), -]; + +let tests = [("Menhir elaboration tests", MenhirElaborationTests.tests)]; diff --git a/test/haz3ltest.re b/test/haz3ltest.re index de6ced8f5c..4951e830f5 100644 --- a/test/haz3ltest.re +++ b/test/haz3ltest.re @@ -5,10 +5,10 @@ let (suite, _) = ~and_exit=false, "Dynamics", [ - ("Elaboration", Test_Elaboration.elaboration_tests), ("Parser", Test_Menhir.tests), ("Statics", Test_Statics.tests), ("Evaluator", Test_Evaluator.tests), - ], + ] + @ Test_Elaboration.tests, ); Junit.to_file(Junit.make([suite]), "junit_tests.xml"); From dab05cbcd15d339ee613ce463da37b52880d9db4 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 6 Oct 2024 18:59:01 -0400 Subject: [PATCH 055/281] Add back plain elaboration tests --- test/Test_Elaboration.re | 223 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 222 insertions(+), 1 deletion(-) diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 9eb2991978..0b9c7fe482 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -12,6 +12,224 @@ let mk_map = Statics.mk(CoreSettings.on, Builtins.ctx_init); let dhexp_of_uexp = u => Elaborator.elaborate(mk_map(u), u) |> fst; let alco_check = dhexp_typ |> Alcotest.check; +module PlainTests = { + let u1: Exp.t = {ids: [id_at(0)], term: Int(8), copied: false}; + let single_integer = () => + alco_check("Integer literal 8", u1, dhexp_of_uexp(u1)); + + let u2: Exp.t = {ids: [id_at(0)], term: EmptyHole, copied: false}; + let empty_hole = () => alco_check("Empty hole", u2, dhexp_of_uexp(u2)); + + let u3: Exp.t = { + ids: [id_at(0)], + term: Parens({ids: [id_at(1)], term: Var("y"), copied: false}), + copied: false, + }; + + let free_var = () => alco_check("free variable", u3, dhexp_of_uexp(u3)); + + let u4: Exp.t = + Let( + Tuple([Var("a") |> Pat.fresh, Var("b") |> Pat.fresh]) |> Pat.fresh, + Tuple([Int(4) |> Exp.fresh, Int(6) |> Exp.fresh]) |> Exp.fresh, + BinOp(Int(Minus), Var("a") |> Exp.fresh, Var("b") |> Exp.fresh) + |> Exp.fresh, + ) + |> Exp.fresh; + + let let_exp = () => + alco_check("Let expression for tuple (a, b)", u4, dhexp_of_uexp(u4)); + + let u5 = + BinOp(Int(Plus), Bool(false) |> Exp.fresh, Var("y") |> Exp.fresh) + |> Exp.fresh; + + let d5 = + BinOp( + Int(Plus), + FailedCast( + Bool(false) |> Exp.fresh, + Bool |> Typ.fresh, + Int |> Typ.fresh, + ) + |> Exp.fresh, + Cast( + Var("y") |> Exp.fresh, + Unknown(Internal) |> Typ.fresh, + Int |> Typ.fresh, + ) + |> Exp.fresh, + ) + |> Exp.fresh; + + let bin_op = () => + alco_check( + "Inconsistent binary integer operation (plus)", + d5, + dhexp_of_uexp(u5), + ); + + let u6: Exp.t = + If(Bool(false) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) + |> Exp.fresh; + + let consistent_if = () => + alco_check( + "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", + u6, + dhexp_of_uexp(u6), + ); + + // x => 4 + 5 + let f = + Fun( + Var("x") |> Pat.fresh, + BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) + |> Exp.fresh, + None, + None, + ) + |> Exp.fresh; + let unapplied_function = () => + alco_check("A function", f, dhexp_of_uexp(f)); + + let u7: Exp.t = Ap(Forward, f, Var("y") |> Exp.fresh) |> Exp.fresh; + + let ap_fun = () => + alco_check("Application of a function", u7, dhexp_of_uexp(u7)); + + let u8: Exp.t = + Match( + BinOp(Int(Equals), Int(4) |> Exp.fresh, Int(3) |> Exp.fresh) + |> Exp.fresh, + [ + (Bool(true) |> Pat.fresh, Int(24) |> Exp.fresh), + (Bool(false) |> Pat.fresh, Bool(false) |> Exp.fresh), + ], + ) + |> Exp.fresh; + + let d8: Exp.t = + Match( + BinOp(Int(Equals), Int(4) |> Exp.fresh, Int(3) |> Exp.fresh) + |> Exp.fresh, + [ + ( + Bool(true) |> Pat.fresh, + Cast( + Int(24) |> Exp.fresh, + Int |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Exp.fresh, + ), + ( + Bool(false) |> Pat.fresh, + Cast( + Bool(false) |> Exp.fresh, + Bool |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Exp.fresh, + ), + ], + ) + |> Exp.fresh; + + let inconsistent_case = () => + alco_check( + "Inconsistent branches where the first branch is an integer and second branch is a boolean", + d8, + dhexp_of_uexp(u8), + ); + + let u9: Exp.t = + Let( + Cast( + Var("f") |> Pat.fresh, + Arrow(Int |> Typ.fresh, Int |> Typ.fresh) |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Pat.fresh, + Fun( + Var("x") |> Pat.fresh, + BinOp(Int(Plus), Int(1) |> Exp.fresh, Var("x") |> Exp.fresh) + |> Exp.fresh, + None, + None, + ) + |> Exp.fresh, + Int(55) |> Exp.fresh, + ) + |> Exp.fresh; + + let d9: Exp.t = + Let( + Var("f") |> Pat.fresh, + Fun( + Var("x") |> Pat.fresh, + BinOp(Int(Plus), Int(1) |> Exp.fresh, Var("x") |> Exp.fresh) + |> Exp.fresh, + None, + Some("f"), + ) + |> Exp.fresh, + Int(55) |> Exp.fresh, + ) + |> Exp.fresh; + + let let_fun = () => + alco_check( + "Let expression for function which is not recursive", + d9, + dhexp_of_uexp(u9), + ); + + let deferral = () => + alco_check( + "string_sub(\"hello\", 1, _)", + dhexp_of_uexp( + DeferredAp( + Var("string_sub") |> Exp.fresh, + [ + String("hello") |> Exp.fresh, + Int(1) |> Exp.fresh, + Deferral(InAp) |> Exp.fresh, + ], + ) + |> Exp.fresh, + ), + dhexp_of_uexp( + DeferredAp( + Var("string_sub") |> Exp.fresh, + [ + String("hello") |> Exp.fresh, + Int(1) |> Exp.fresh, + Deferral(InAp) |> Exp.fresh, + ], + ) + |> Exp.fresh, + ), + ); + + let tests = [ + test_case("Single integer", `Quick, single_integer), + test_case("Empty hole", `Quick, empty_hole), + test_case("Free variable", `Quick, free_var), + test_case("Let expression", `Quick, let_exp), + test_case("Inconsistent binary operation", `Quick, bin_op), + test_case("Consistent if statement", `Quick, consistent_if), + test_case("An unapplied function", `Quick, unapplied_function), + test_case("Application of function on free variable", `Quick, ap_fun), + test_case("Inconsistent case statement", `Quick, inconsistent_case), + test_case("Let expression for a function", `Quick, let_fun), + test_case( + "Function application with a deferred argument", + `Quick, + deferral, + ), + ]; +}; module MenhirElaborationTests = { let alco_check_menhir = (name: string, dhexp: string, uexp: Term.Exp.t) => alco_check( @@ -445,4 +663,7 @@ x ]; }; -let tests = [("Menhir elaboration tests", MenhirElaborationTests.tests)]; +let tests = [ + ("Elaboration tests", PlainTests.tests), + ("Menhir elaboration tests", MenhirElaborationTests.tests), +]; From dc515080b53a6afa0f76c6537ebc6a8685ce880f Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 6 Oct 2024 19:05:13 -0400 Subject: [PATCH 056/281] Use alco_check_menhir in all the menhir elaboration tests --- test/Test_Elaboration.re | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-) diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 0b9c7fe482..6555438d0a 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -293,11 +293,9 @@ let f = copied: false, }; let free_var_menhir = () => - alco_check( + alco_check_menhir( "Nonempty hole with free variable (menhir)", - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program("y"), - ), + "y", dhexp_of_uexp(free_var_uexp), ); @@ -309,11 +307,9 @@ let f = let bin_op_str = "false? Int> + y Int>"; let bin_op_menhir = () => - alco_check( + alco_check_menhir( "Inconsistent binary integer operation (plus)", - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(bin_op_str), - ), + bin_op_str, dhexp_of_uexp(bin_op_uexp), ); @@ -360,11 +356,9 @@ let f = (fun x -> 4 + 5)(y) "; let ap_fun_menhir = () => - alco_check( + alco_check_menhir( "Application of a function (menhir)", - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(ap_fun_str), - ), + ap_fun_str, dhexp_of_uexp(ap_fun_uexp), ); @@ -377,11 +371,9 @@ let f = if false then 8 else 6 "; let consistent_if_menhir = () => - alco_check( + alco_check_menhir( "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(consistent_if_str), - ), + consistent_if_str, dhexp_of_uexp(consistent_if_uexp), ); From f2e14fe2aba0381fb6b1f498f6728a35af1257c6 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sun, 13 Oct 2024 21:12:03 -0400 Subject: [PATCH 057/281] Added menhir parser readme --- src/haz3lmenhir/README.md | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 src/haz3lmenhir/README.md diff --git a/src/haz3lmenhir/README.md b/src/haz3lmenhir/README.md new file mode 100644 index 0000000000..059d9ec8f0 --- /dev/null +++ b/src/haz3lmenhir/README.md @@ -0,0 +1,8 @@ +# Hazel Menhir Parser +> This directory contains a Menhir parser for textual Hazel `Exp` syntax and a utility to convert the Menhir AST to post-elaboration `Exp`. This is used for Hazel elaborator unit tests +* The Menhir parser is located in the `Parser.mly` file +* The ocamllex lexer can be found in `Lexer.mll` +* `Interface.re` contains functions to interface with the parser and parse text into an `AST` structure +* The parser's AST is defined in `AST.re` +* `Conversion.re` contains utility functions to convert the `AST` structure into the Hazel post-elaboration `Exp` structure +* Examples of the textual syntax can be found in the `Exp` module of the `TermBase.re` file From dd7dd801bd7b1c32b3782093be6a195d57b61a7a Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sun, 13 Oct 2024 22:16:57 -0400 Subject: [PATCH 058/281] Started restructuring the menhir parser tests --- test/Test_Menhir.re | 48 ++++++++++++++++++++++++++++++++------------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 4859f381e0..cb2380fc40 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -1,35 +1,55 @@ open Haz3lmenhir; open Alcotest; +open Haz3lcore; let testable_ast = testable(Fmt.using(AST.show_exp, Fmt.string), (==)); -let parser_test = (a, expected, actual, ()) => - Alcotest.check( - testable_ast, - a, - expected, - Haz3lmenhir.Interface.parse_program(actual), +let exp_typ = + testable( + Fmt.using(Haz3lcore.Exp.show, Fmt.string), + Haz3lcore.DHExp.fast_equal, ); -let fun_exp = AST.Fun(VarPat("x"), Var("x"), None); +let alco_check = exp_typ |> Alcotest.check; +let mk_map = Statics.mk(CoreSettings.on, Builtins.ctx_init); +let dhexp_of_uexp = u => Elaborator.elaborate(mk_map(u), u) |> fst; + +let parser_test = (name: string, exp: Term.Exp.t, menhir: string, ()) => + alco_check( + name, + exp, + dhexp_of_uexp( + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(menhir), + ), + ), + ); + +let fun_exp: Exp.t = + Fun(Var("x") |> Pat.fresh, Var("x") |> Exp.fresh, None, None) |> Exp.fresh; let fun_str = "fun x -> x"; let tests = [ test_case( "Integer Literal", `Quick, - parser_test("Same Integer", Int(8), "8"), + parser_test("Same Integer", Int(8) |> Exp.fresh, "8"), ), test_case("Fun", `Quick, parser_test("Fun", fun_exp, fun_str)), test_case( "String Literal", `Quick, - parser_test("Same String", String("Hello World"), "\"Hello World\""), - ), - test_case( - "Deferred Ap", - `Quick, - parser_test("Deferred Ap", AST.ApExp(Var("x"), Deferral), "x(_)"), + parser_test( + "Same String", + String("Hello World") |> Exp.fresh, + "\"Hello World\"", + ), ), + //NOTE: leaving out deferrals for now due to bug + // test_case( + // "Deferred Ap", + // `Quick, + // parser_test("Deferred Ap", , "x(_)"), + // ), ]; From 39d077f12f12afeddbf2c1958bba5c2ab3a1a3e4 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 24 Oct 2024 10:49:04 -0400 Subject: [PATCH 059/281] Add additional parser tests --- test/Test_Menhir.re | 104 +++++++++++++++++++++++++++++++------------- 1 file changed, 74 insertions(+), 30 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index cb2380fc40..ff82d9b090 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -12,44 +12,88 @@ let exp_typ = let alco_check = exp_typ |> Alcotest.check; -let mk_map = Statics.mk(CoreSettings.on, Builtins.ctx_init); -let dhexp_of_uexp = u => Elaborator.elaborate(mk_map(u), u) |> fst; - -let parser_test = (name: string, exp: Term.Exp.t, menhir: string, ()) => - alco_check( - name, - exp, - dhexp_of_uexp( +let parser_test = (name: string, exp: Term.Exp.t, menhir: string) => + test_case(name, `Quick, () => + alco_check( + name, + exp, Haz3lmenhir.Conversion.Exp.of_menhir_ast( Haz3lmenhir.Interface.parse_program(menhir), ), - ), + ) ); let fun_exp: Exp.t = Fun(Var("x") |> Pat.fresh, Var("x") |> Exp.fresh, None, None) |> Exp.fresh; -let fun_str = "fun x -> x"; let tests = [ - test_case( - "Integer Literal", - `Quick, - parser_test("Same Integer", Int(8) |> Exp.fresh, "8"), - ), - test_case("Fun", `Quick, parser_test("Fun", fun_exp, fun_str)), - test_case( + parser_test("Integer Literal", Int(8) |> Exp.fresh, "8"), + parser_test("Fun", fun_exp, "fun x -> x"), + parser_test( "String Literal", - `Quick, - parser_test( - "Same String", - String("Hello World") |> Exp.fresh, - "\"Hello World\"", - ), - ), - //NOTE: leaving out deferrals for now due to bug - // test_case( - // "Deferred Ap", - // `Quick, - // parser_test("Deferred Ap", , "x(_)"), - // ), + String("Hello World") |> Exp.fresh, + "\"Hello World\"", + ), + parser_test("Bool Literal", Bool(true) |> Exp.fresh, "true"), + parser_test("Empty Hole", EmptyHole |> Exp.fresh, "?"), + parser_test("Var", Var("x") |> Exp.fresh, "x"), + parser_test("Parens", Parens(Var("y") |> Exp.fresh) |> Exp.fresh, "(y)"), + parser_test( + "BinOp", + BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) |> Exp.fresh, + "4 + 5", + ), + parser_test( + "Let", + Let(Var("x") |> Pat.fresh, Int(5) |> Exp.fresh, Var("x") |> Exp.fresh) + |> Exp.fresh, + "let x = 5 in x", + ), + parser_test( + "Tuple", + Tuple([Int(4) |> Exp.fresh, Int(5) |> Exp.fresh]) |> Exp.fresh, + "(4, 5)" // TODO Verify with maketerm. Should this be parens or not + ), + parser_test( + "Match", + Match( + Int(4) |> Exp.fresh, + [ + (Int(1) |> Pat.fresh, String("hello") |> Exp.fresh), + (Wild |> Pat.fresh, String("world") |> Exp.fresh), + ], + ) + |> Exp.fresh, + {|case 4 + | 1 => "hello" + | _ => "world" + end|}, + ), + parser_test( + "If", + If(Bool(true) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) + |> Exp.fresh, + "if true then 8 else 6", + ), + parser_test( + "Deferred Ap", + DeferredAp(Var("x") |> Exp.fresh, [Deferral(InAp) |> Exp.fresh]) + |> Exp.fresh, + "x(_)", + ), + parser_test( + "Cons", + Cons(Int(1) |> Exp.fresh, ListLit([]) |> Exp.fresh) |> Exp.fresh, + "1 :: []", + ), + parser_test( + "ListLit", + ListLit([ + Int(1) |> Exp.fresh, + Int(2) |> Exp.fresh, + Int(3) |> Exp.fresh, + ]) + |> Exp.fresh, + "[1, 2, 3]", + ), ]; From ce261733f4f5746a40bdc25f5d3f4766f671cb69 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 24 Oct 2024 11:00:09 -0400 Subject: [PATCH 060/281] Add more menhir tests including a failing constructor test --- test/Test_Menhir.re | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index ff82d9b090..8b1818f34f 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -96,4 +96,15 @@ let tests = [ |> Exp.fresh, "[1, 2, 3]", ), + parser_test( + "Constructor", + Constructor("A", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, + "A", + ), + parser_test( + "Type Alias", + TyAlias(Var("x") |> TPat.fresh, Int |> Typ.fresh, Int(1) |> Exp.fresh) + |> Exp.fresh, + "type x = Int in 1", + ), ]; From 01d6f3a539751138370a2f2e1f8992d02f329fa6 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 24 Oct 2024 11:16:34 -0400 Subject: [PATCH 061/281] Add more tests --- test/Test_Menhir.re | 86 ++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 77 insertions(+), 9 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 8b1818f34f..26b61b114b 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -12,15 +12,25 @@ let exp_typ = let alco_check = exp_typ |> Alcotest.check; -let parser_test = (name: string, exp: Term.Exp.t, menhir: string) => - test_case(name, `Quick, () => - alco_check( - name, - exp, - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(menhir), - ), - ) +// Existing recovering parser +let make_term_parse = (s: string) => + MakeTerm.from_zip_for_sem(Option.get(Printer.zipper_of_string(s))).term; + +let parser_test = (name: string, exp: Term.Exp.t, actual: string) => + test_case( + name, + `Quick, + () => { + alco_check("Does not match MakeTerm", exp, make_term_parse(actual)); + + alco_check( + name ++ " matches expected type", + exp, + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(actual), + ), + ); + }, ); let fun_exp: Exp.t = @@ -107,4 +117,62 @@ let tests = [ |> Exp.fresh, "type x = Int in 1", ), + parser_test( + "Test", + Test( + BinOp(Int(Equals), Int(3) |> Exp.fresh, Int(3) |> Exp.fresh) + |> Exp.fresh, + ) + |> Exp.fresh, + "test 3 == 3 end", + ), + parser_test( + "Filter", + Filter( + Filter({act: (Eval, One), pat: Int(3) |> Exp.fresh}), + Int(3) |> Exp.fresh, + ) + |> Exp.fresh, + "eval 3 in 3" // TODO Use other filter commands + ), + parser_test( + "List Concat", + ListConcat( + ListLit([Int(1) |> Exp.fresh, Int(2) |> Exp.fresh]) |> Exp.fresh, + ListLit([Int(3) |> Exp.fresh, Int(4) |> Exp.fresh]) |> Exp.fresh, + ) + |> Exp.fresh, + "[1, 2] @ [3, 4]", + ), + parser_test( + "Integer Ops", + BinOp( + Int(LessThan), + BinOp( + Int(Minus), + BinOp( + Int(Plus), + UnOp(Int(Minus), Int(1) |> Exp.fresh) |> Exp.fresh, + Int(2) |> Exp.fresh, + ) + |> Exp.fresh, + BinOp( + Int(Divide), + Int(3) |> Exp.fresh, + BinOp( + Int(Times), + Int(4) |> Exp.fresh, + BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) + |> Exp.fresh, + ) + |> Exp.fresh, + ) + |> Exp.fresh, + ) + |> Exp.fresh, + Int(8) |> Exp.fresh, + ) + |> Exp.fresh, + "-1 + 2 - 3 / 4 * 5 ** 6 < 8" // TODO Add the remaining operators + ), ]; From 9a3b5ddb708bbe52152e3363b8244d5e39d320a8 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 24 Oct 2024 11:25:33 -0400 Subject: [PATCH 062/281] Add test for parsing named function --- test/Test_Menhir.re | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 26b61b114b..12f3846b7a 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -175,4 +175,20 @@ let tests = [ |> Exp.fresh, "-1 + 2 - 3 / 4 * 5 ** 6 < 8" // TODO Add the remaining operators ), + test_case("named_function", `Quick, () => { + alco_check( + "named_function matches expected type", + Fun( + Pat.Var("x") |> Pat.fresh, + BinOp(Int(Plus), Var("x") |> Exp.fresh, Int(5) |> Exp.fresh) + |> Exp.fresh, + None, + Some("f"), + ) + |> Exp.fresh, + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program("named_fun f x -> x + 5"), + ), + ) + }), ]; From aef64e95442bc793eaa41c3ebc9da77e535224a6 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 24 Oct 2024 14:29:06 -0400 Subject: [PATCH 063/281] Add test for parsing named function and additional parser tests --- test/Test_Menhir.re | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 12f3846b7a..5e6c516c6d 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -15,7 +15,8 @@ let alco_check = exp_typ |> Alcotest.check; // Existing recovering parser let make_term_parse = (s: string) => MakeTerm.from_zip_for_sem(Option.get(Printer.zipper_of_string(s))).term; - + +// TODO Assert against result instead of exception for parse failure for better error messages let parser_test = (name: string, exp: Term.Exp.t, actual: string) => test_case( name, @@ -175,6 +176,21 @@ let tests = [ |> Exp.fresh, "-1 + 2 - 3 / 4 * 5 ** 6 < 8" // TODO Add the remaining operators ), + parser_test( + "Let binding with type ascription", + Let( + Cast( + Var("x") |> Pat.fresh, + Int |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Pat.fresh, + Int(5) |> Exp.fresh, + Var("x") |> Exp.fresh, + ) + |> Exp.fresh, + "let (x : Int) = 5 in x", + ), test_case("named_function", `Quick, () => { alco_check( "named_function matches expected type", From 15a82a0a2ce8bc98803bc086df377ac7f2c33837 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 24 Oct 2024 14:29:26 -0400 Subject: [PATCH 064/281] Refmt --- test/Test_Menhir.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 5e6c516c6d..2ea92f9a2f 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -15,7 +15,7 @@ let alco_check = exp_typ |> Alcotest.check; // Existing recovering parser let make_term_parse = (s: string) => MakeTerm.from_zip_for_sem(Option.get(Printer.zipper_of_string(s))).term; - + // TODO Assert against result instead of exception for parse failure for better error messages let parser_test = (name: string, exp: Term.Exp.t, actual: string) => test_case( From 4a2fe8b45f4e0de35715ec37e3e6f0634acc2524 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 25 Oct 2024 12:02:50 -0400 Subject: [PATCH 065/281] Change constructor tests --- test/Test_Menhir.re | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 2ea92f9a2f..45580ca5e6 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -16,6 +16,18 @@ let alco_check = exp_typ |> Alcotest.check; let make_term_parse = (s: string) => MakeTerm.from_zip_for_sem(Option.get(Printer.zipper_of_string(s))).term; +let menhir_matches = (name: string, exp: Term.Exp.t, actual: string) => + alco_check( + name ++ " matches expected type", + exp, + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(actual), + ), + ); + +let menhir_only_test = (name: string, exp: Term.Exp.t, actual: string) => + test_case(name, `Quick, () => {menhir_matches(name, exp, actual)}); + // TODO Assert against result instead of exception for parse failure for better error messages let parser_test = (name: string, exp: Term.Exp.t, actual: string) => test_case( @@ -24,13 +36,7 @@ let parser_test = (name: string, exp: Term.Exp.t, actual: string) => () => { alco_check("Does not match MakeTerm", exp, make_term_parse(actual)); - alco_check( - name ++ " matches expected type", - exp, - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(actual), - ), - ); + menhir_matches(name, exp, actual); }, ); @@ -107,10 +113,10 @@ let tests = [ |> Exp.fresh, "[1, 2, 3]", ), - parser_test( + menhir_only_test( "Constructor", Constructor("A", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, - "A", + "A:Unknown Internal" // This is source incompatible with make_term which does not find the type. We also don't allow expression casts. ), parser_test( "Type Alias", From 00ab1de80c758edfdaa85671cdf34df57ac45b29 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 25 Oct 2024 12:12:55 -0400 Subject: [PATCH 066/281] Fix filter parsing --- src/haz3lmenhir/Parser.mly | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 67bb0e6dee..3017a529df 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -254,7 +254,7 @@ exp: | FIX; p = pat; DASH_ARROW; e = exp { FixF(p, e) } | TYP_FUN; t = tpat; DASH_ARROW; e = exp {TypFun(t, e)} | QUESTION { EmptyHole } - | a = filterAction; cond = exp; COMMA; body = exp { Filter(a, cond, body)} + | a = filterAction; cond = exp; IN; body = exp { Filter(a, cond, body)} | TEST; e = exp; END { Test(e) } | e1 = exp; AT_SYMBOL; e2 = exp { ListConcat(e1, e2) } | e1 = exp; CONS; e2 = exp { Cons(e1, e2) } From be06410ef8c8c44828085dc19b4112762dbf99cd Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 25 Oct 2024 12:21:14 -0400 Subject: [PATCH 067/281] Fix integer operator test --- test/Test_Menhir.re | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 45580ca5e6..8b4401e874 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -136,7 +136,7 @@ let tests = [ parser_test( "Filter", Filter( - Filter({act: (Eval, One), pat: Int(3) |> Exp.fresh}), + Filter({act: (Eval, All), pat: Int(3) |> Exp.fresh}), Int(3) |> Exp.fresh, ) |> Exp.fresh, @@ -154,7 +154,7 @@ let tests = [ parser_test( "Integer Ops", BinOp( - Int(LessThan), + Int(GreaterThanOrEqual), BinOp( Int(Minus), BinOp( @@ -180,7 +180,7 @@ let tests = [ Int(8) |> Exp.fresh, ) |> Exp.fresh, - "-1 + 2 - 3 / 4 * 5 ** 6 < 8" // TODO Add the remaining operators + "-1 + 2 - 3 / 4 * 5 ** 6 >= 8" // TODO Add the remaining operators. < is also currently broken ), parser_test( "Let binding with type ascription", From 6b1c3b0627f45456308bafb52e7fb93864619fd7 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 25 Oct 2024 12:24:13 -0400 Subject: [PATCH 068/281] Simplify test --- test/Test_Menhir.re | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 8b4401e874..7a67a9376d 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -197,20 +197,16 @@ let tests = [ |> Exp.fresh, "let (x : Int) = 5 in x", ), - test_case("named_function", `Quick, () => { - alco_check( - "named_function matches expected type", - Fun( - Pat.Var("x") |> Pat.fresh, - BinOp(Int(Plus), Var("x") |> Exp.fresh, Int(5) |> Exp.fresh) - |> Exp.fresh, - None, - Some("f"), - ) + menhir_only_test( + "named_function", + Fun( + Pat.Var("x") |> Pat.fresh, + BinOp(Int(Plus), Var("x") |> Exp.fresh, Int(5) |> Exp.fresh) |> Exp.fresh, - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program("named_fun f x -> x + 5"), - ), + None, + Some("f"), ) - }), + |> Exp.fresh, + "named_fun f x -> x + 5", + ), ]; From 51ec3c42efe2829c13deb9b6b136dda939c6e56b Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 25 Oct 2024 13:02:55 -0400 Subject: [PATCH 069/281] Add a test that compares the menhir parser to maketerm with the basic reference page contents --- test/Test_Menhir.re | 30 +++++++++++++++++++++++++++--- 1 file changed, 27 insertions(+), 3 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 7a67a9376d..a6c9c11b99 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -40,6 +40,17 @@ let parser_test = (name: string, exp: Term.Exp.t, actual: string) => }, ); +let menhir_maketerm_equivalent_test = (name: string, actual: string) => + test_case(name, `Quick, () => { + alco_check( + "Does not match MakeTerm", + make_term_parse(actual), + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(actual), + ), + ) + }); + let fun_exp: Exp.t = Fun(Var("x") |> Pat.fresh, Var("x") |> Exp.fresh, None, None) |> Exp.fresh; @@ -82,9 +93,9 @@ let tests = [ ) |> Exp.fresh, {|case 4 - | 1 => "hello" - | _ => "world" - end|}, + | 1 => "hello" + | _ => "world" + end|}, ), parser_test( "If", @@ -209,4 +220,17 @@ let tests = [ |> Exp.fresh, "named_fun f x -> x + 5", ), + { + let strip_comments = str => { + let re = Str.regexp("#[^#]*#"); + Str.global_replace(re, "", str); + }; + let basic_reference = + Haz3lweb.Init.startup.documentation + |> (((_, slides, _)) => slides) + |> List.assoc("Basic Reference") + |> (slide => strip_comments(slide.backup_text)); + + menhir_maketerm_equivalent_test("Basic Reference", basic_reference); + }, ]; From ed962c0354b29f7e5036ba7c39491e0872a7f64f Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 25 Oct 2024 14:01:24 -0400 Subject: [PATCH 070/281] Add haz3lweb library to test dependencies --- test/dune | 1 + 1 file changed, 1 insertion(+) diff --git a/test/dune b/test/dune index 38823aef07..3097b79859 100644 --- a/test/dune +++ b/test/dune @@ -4,6 +4,7 @@ (name haz3ltest) (libraries haz3lcore + haz3lweb alcotest sexplib base From 9d2b7dbca7f75532186d9275115fa67ccb0e48e2 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 28 Oct 2024 18:55:21 -0400 Subject: [PATCH 071/281] More menhir parser tests added --- test/Test_Elaboration.re | 2 + test/Test_Menhir.re | 178 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 180 insertions(+) diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 6555438d0a..caacbbee39 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -231,6 +231,8 @@ module PlainTests = { ]; }; module MenhirElaborationTests = { + //dhexp = expected + //uexp = tested let alco_check_menhir = (name: string, dhexp: string, uexp: Term.Exp.t) => alco_check( name, diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index cb2380fc40..40f4bcabdd 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -4,6 +4,9 @@ open Haz3lcore; let testable_ast = testable(Fmt.using(AST.show_exp, Fmt.string), (==)); +let ids = List.init(12, _ => Id.mk()); +let id_at = x => x |> List.nth(ids); + let exp_typ = testable( Fmt.using(Haz3lcore.Exp.show, Fmt.string), @@ -15,6 +18,7 @@ let alco_check = exp_typ |> Alcotest.check; let mk_map = Statics.mk(CoreSettings.on, Builtins.ctx_init); let dhexp_of_uexp = u => Elaborator.elaborate(mk_map(u), u) |> fst; +//exp = expected, menhir = test let parser_test = (name: string, exp: Term.Exp.t, menhir: string, ()) => alco_check( name, @@ -30,6 +34,178 @@ let fun_exp: Exp.t = Fun(Var("x") |> Pat.fresh, Var("x") |> Exp.fresh, None, None) |> Exp.fresh; let fun_str = "fun x -> x"; +//Test for a let function +let let_fun_uexp: Exp.t = + Let( + Var("f") |> Pat.fresh, + Fun(Var("x") |> Pat.fresh, Int(1) |> Exp.fresh, None, None) |> Exp.fresh, + Int(55) |> Exp.fresh, + ) + |> Exp.fresh; + +let let_fun_str = " +let f = + fun x -> + 1 + f + in +55"; + +let let_fun_test = () => + parser_test( + "Let expression for a function which is not recursive (menhir)", + let_fun_uexp, + let_fun_str, + ); + +//Test for an empty hole +let empty_hole_str = "?"; +let empty_hole_uexp: Exp.t = { + ids: [id_at(0)], + term: EmptyHole, + copied: false, +}; +let empty_hole_test = () => + parser_test("Empty hole (menhir)", empty_hole_uexp, empty_hole_str); + +//Test for a free variable +let free_var_uexp: Exp.t = { + ids: [id_at(0)], + term: Parens({ids: [id_at(1)], term: Var("y"), copied: false}), + copied: false, +}; +let free_var_test = () => + parser_test( + "Nonempty hole with free variable (menhir)", + dhexp_of_uexp(free_var_uexp), + "y", + ); + +//Menhir test for a binary operation +let bin_op_uexp: Exp.t = + BinOp(Int(Plus), Int(1) |> Exp.fresh, Int(2) |> Exp.fresh) |> Exp.fresh; + +let bin_op_str = "1 + 2"; + +let bin_op_test = () => + parser_test( + "binary integer operation (plus)", + dhexp_of_uexp(bin_op_uexp), + bin_op_str, + ); + +//Inconsistent branches menhir test +let case_menhir_str = " + case 4 == 3 + | true => 24 + | false => 32 +end +"; +let case_uexp: Exp.t = + Match( + BinOp(Int(Equals), Int(4) |> Exp.fresh, Int(3) |> Exp.fresh) + |> Exp.fresh, + [ + (Bool(true) |> Pat.fresh, Int(24) |> Exp.fresh), + (Bool(false) |> Pat.fresh, Int(32) |> Exp.fresh), + ], + ) + |> Exp.fresh; +let inconsistent_case_test = () => + parser_test("Case test", case_uexp, case_menhir_str); + +//Function free var application menhir test +let ap_fun_uexp: Exp.t = + Ap( + Forward, + Fun( + Var("x") |> Pat.fresh, + BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) + |> Exp.fresh, + None, + None, + ) + |> Exp.fresh, + Var("y") |> Exp.fresh, + ) + |> Exp.fresh; +let ap_fun_str = " + (fun x -> 4 + 5)(y) +"; +let ap_fun_test = () => + parser_test( + "Application of a function (menhir)", + dhexp_of_uexp(ap_fun_uexp), + ap_fun_str, + ); + +//Consistent if statement menhir test +let consistent_if_uexp: Exp.t = + If(Bool(false) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) + |> Exp.fresh; + +let consistent_if_str = " + if false then 8 else 6 +"; +let consistent_if_menhir = () => + parser_test( + "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", + dhexp_of_uexp(consistent_if_uexp), + consistent_if_str, + ); + +//Single integer menhir test +let single_int_str = "8"; +let single_int_uexp: Exp.t = { + ids: [id_at(0)], + term: Int(8), + copied: false, +}; +let single_integer_menhir = () => + parser_test( + "Single integer test (menhir)", + single_int_uexp, + single_int_str, + ); + +// //Menhir let expression test +// let let_exp_str = "let (a, b) = (4, 6) in a - b"; +// let let_exp_uexp: Exp.t = +// Let( +// Tuple([Var("a") |> Pat.fresh, Var("b") |> Pat.fresh]) |> Pat.fresh, +// Tuple([Int(4) |> Exp.fresh, Int(6) |> Exp.fresh]) |> Exp.fresh, +// BinOp(Int(Minus), Var("a") |> Exp.fresh, Var("b") |> Exp.fresh) +// |> Exp.fresh, +// ) +// |> Exp.fresh; +// let let_exp_menhir = () => +// alco_check_menhir( +// "Let expression for tuple (a, b) (menhir)", +// let_exp_str, +// let_exp_uexp, +// ); +// +// let typ_ap_str = "(typfun x -> 4) @ "; +// let typ_ap_uexp: Exp.t = +// TypAp( +// TypFun(Var("x") |> TPat.fresh, Int(4) |> Exp.fresh, None) |> Exp.fresh, +// Int |> Typ.fresh, +// ) +// |> Exp.fresh; +// let typ_ap_menhir = () => +// alco_check_menhir("Type ap test (menhir)", typ_ap_str, typ_ap_uexp); +// +// let failed_cast_str = "1 ? String>"; +// let failed_cast_uexp: Exp.t = +// FailedCast(Int(1) |> Exp.fresh, Int |> Typ.fresh, String |> Typ.fresh) +// |> Exp.fresh; +// let failed_cast_menhir = () => +// alco_check_menhir( +// "Failed cast test (menhir)", +// failed_cast_str, +// failed_cast_uexp, +// ); + let tests = [ test_case( "Integer Literal", @@ -52,4 +228,6 @@ let tests = [ // `Quick, // parser_test("Deferred Ap", , "x(_)"), // ), + test_case("Ap Fun", `Quick, ap_fun_test()), + test_case("Single integer", `Quick, single_integer_menhir()), ]; From d8f265236c8d145c4f89da7a83ba7a8528d93fb5 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 31 Oct 2024 10:34:31 -0400 Subject: [PATCH 072/281] Add coverage instrumentation to haz3lmenhir library --- src/haz3lmenhir/dune | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/haz3lmenhir/dune b/src/haz3lmenhir/dune index 0c1bf836b8..d9a9683a19 100644 --- a/src/haz3lmenhir/dune +++ b/src/haz3lmenhir/dune @@ -2,6 +2,8 @@ (name haz3lmenhir) (libraries util re sexplib unionFind haz3lcore) (modules AST Conversion Interface Lexer Parser) + (instrumentation + (backend bisect_ppx)) (preprocess (pps ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) From eb5ba2becf741718eea7afcfb2f67296426bed4b Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 4 Nov 2024 07:58:50 -0500 Subject: [PATCH 073/281] Added hole replacement to the basic_reference parser test --- test/Test_Menhir.re | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 0bb114bf55..2fc8147848 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -354,11 +354,18 @@ let tests = [ // let re = Str.regexp("#[^#]*#"); // Str.global_replace(re, "", str); // }; + // let replace_holes = str => { + // let re = Str.regexp("= in"); + // Str.global_replace(re, "= ? in", str); + // }; + // // let basic_reference = // Haz3lweb.Init.startup.documentation // |> (((_, slides, _)) => slides) // |> List.assoc("Basic Reference") - // |> (slide => strip_comments(slide.backup_text)); + // |> (slide => strip_comments(slide.backup_text)) + // |> replace_holes; + // // print_endline(basic_reference); // // menhir_maketerm_equivalent_test("Basic Reference", basic_reference); From 6b3655264c2f6545f2e4cae56a7a3b830b600f22 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 4 Nov 2024 08:16:41 -0500 Subject: [PATCH 074/281] Merges --- src/haz3lweb/util/SvgUtil.re | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/src/haz3lweb/util/SvgUtil.re b/src/haz3lweb/util/SvgUtil.re index 5809f70432..0b28cf9836 100644 --- a/src/haz3lweb/util/SvgUtil.re +++ b/src/haz3lweb/util/SvgUtil.re @@ -285,10 +285,18 @@ module OrthogonalPolygon = { let min_max = Point.{x: min.x, y: max_y}; let max_min = Point.{x: max_x, y: min.y}; [ - // left sides point in negative direction - {src: min_max, dst: min, next: None}, - // right sides point in positive direction - {src: max_min, dst: max, next: None}, + { + // left sides point in negative direction + src: min_max, + dst: min, + next: None, + }, + { + // right sides point in positive direction + src: max_min, + dst: max, + next: None, + }, ]; }) |> List.flatten From 574c35930e12fdb9b65154b1da2c73daa470a8fd Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 4 Nov 2024 08:22:51 -0500 Subject: [PATCH 075/281] Reworked the constructor menhir parsing to match maketerm --- src/haz3lmenhir/Lexer.mll | 1 + src/haz3lmenhir/Parser.mly | 9 ++++++--- test/Test_Elaboration.re | 2 +- test/Test_Menhir.re | 12 +++++++++++- 4 files changed, 19 insertions(+), 5 deletions(-) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index 7b334fc4e1..7762f622a2 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -109,6 +109,7 @@ rule token = | "typfun" {TYP_FUN} | "type" {TYP} | "$" {DOLLAR_SIGN} + | "~" {TILDE} | "named_fun" {NAMED_FUN} | identifier as i { IDENT(i) } | constructor_ident as i { CONSTRUCTOR_IDENT(i)} diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 5937930287..dddd12e4a2 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -3,7 +3,7 @@ open AST %} - +%token TILDE %token NAMED_FUN %token UNDEF %token SEXP_STRING @@ -110,6 +110,7 @@ open AST %left OPEN_PAREN %left QUESTION %left COLON +%left TILDE (* %left COMMA *) %left AT_SYMBOL %left SEMI_COLON @@ -186,7 +187,8 @@ pat: | WILD { WildPat } | QUESTION { EmptyHolePat } | OPEN_SQUARE_BRACKET; l = separated_list(COMMA, pat); CLOSE_SQUARE_BRACKET; { ListPat(l) } - | c = CONSTRUCTOR_IDENT; COLON; t = typ; { ConstructorPat(c, t) } + | c = CONSTRUCTOR_IDENT { ConstructorPat(c, UnknownType(Internal))} + | c = CONSTRUCTOR_IDENT; TILDE; t = typ; { CastPat(ConstructorPat(c, UnknownType(Internal)), UnknownType(Internal), t) } | p = IDENT { VarPat(p) } | i = INT { IntPat i } | f = FLOAT { FloatPat f } @@ -234,7 +236,8 @@ exp: | i = INT { Int i } | f = FLOAT { Float f } | v = IDENT { Var v } - | c = CONSTRUCTOR_IDENT; COLON; t = typ { Constructor(c, t) } + | c = CONSTRUCTOR_IDENT { Constructor(c, UnknownType(Internal))} + | c = CONSTRUCTOR_IDENT; TILDE; t = typ; { Cast(Constructor(c, UnknownType(Internal)), UnknownType(Internal), t) } | s = STRING { String s} | OPEN_PAREN; e = exp; CLOSE_PAREN { e } | OPEN_PAREN; e = exp; COMMA; l = separated_list(COMMA, exp); CLOSE_PAREN { TupleExp(e :: l) } diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index bd4136b071..3c15680174 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -555,7 +555,7 @@ let f = failed_cast_uexp, ); - let constructor_str = "X: Unknown Internal"; + let constructor_str = "X"; let constructor_uexp: Exp.t = Constructor("X", Unknown(Internal) |> Typ.fresh) |> Exp.fresh; let constructor_menhir = () => diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 2fc8147848..785a206e0c 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -256,7 +256,17 @@ let tests = [ menhir_only_test( "Constructor", Constructor("A", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, - "A:Unknown Internal" // This is source incompatible with make_term which does not find the type. We also don't allow expression casts. + "A", + ), + menhir_only_test( + "Constructor cast", + Cast( + Constructor("A", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, + Unknown(Internal) |> Typ.fresh, + Int |> Typ.fresh, + ) + |> Exp.fresh, + "A ~ Int", ), parser_test( "Type Alias", From 8b79893281eabcd9c93b4a02a486f4c07254c1a9 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 4 Nov 2024 09:05:43 -0500 Subject: [PATCH 076/281] Fixed the invalid reduce/reduce conflict and added LESS_THAN back into the menhir parser --- src/haz3lmenhir/Lexer.mll | 4 + src/haz3lmenhir/Parser.automaton | 7002 ++++++++++++++++++++++++++++++ src/haz3lmenhir/Parser.conflicts | 33 + src/haz3lmenhir/Parser.mly | 17 +- test/Test_Elaboration.re | 2 +- 5 files changed, 7052 insertions(+), 6 deletions(-) create mode 100644 src/haz3lmenhir/Parser.automaton create mode 100644 src/haz3lmenhir/Parser.conflicts diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index 7762f622a2..eea05e16e6 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -110,6 +110,10 @@ rule token = | "type" {TYP} | "$" {DOLLAR_SIGN} | "~" {TILDE} + | "t" {T_TYP} + | "p" {P_PAT} + | "tp" {TP_TPAT} + | "e" {E_EXP} | "named_fun" {NAMED_FUN} | identifier as i { IDENT(i) } | constructor_ident as i { CONSTRUCTOR_IDENT(i)} diff --git a/src/haz3lmenhir/Parser.automaton b/src/haz3lmenhir/Parser.automaton new file mode 100644 index 0000000000..f3c54a01c2 --- /dev/null +++ b/src/haz3lmenhir/Parser.automaton @@ -0,0 +1,7002 @@ +State 0: +## Known stack suffix: +## +## LR(1) items: +program' -> . program [ # ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On program shift to state 236 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 237 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 1: +## Known stack suffix: +## WILD +## LR(1) items: +exp -> WILD . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> WILD + +State 2: +## Known stack suffix: +## UNDEF +## LR(1) items: +exp -> UNDEF . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> UNDEF + +State 3: +## Known stack suffix: +## TYP_FUN +## LR(1) items: +exp -> TYP_FUN . tpat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On QUESTION shift to state 4 +-- On IDENT shift to state 6 +-- On tpat shift to state 7 +## Reductions: + +State 4: +## Known stack suffix: +## QUESTION +## LR(1) items: +tpat -> QUESTION . STRING [ SINGLE_EQUAL DASH_ARROW ] +tpat -> QUESTION . [ SINGLE_EQUAL DASH_ARROW ] +## Transitions: +-- On STRING shift to state 5 +## Reductions: +-- On SINGLE_EQUAL DASH_ARROW +-- reduce production tpat -> QUESTION + +State 5: +## Known stack suffix: +## QUESTION STRING +## LR(1) items: +tpat -> QUESTION STRING . [ SINGLE_EQUAL DASH_ARROW ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL DASH_ARROW +-- reduce production tpat -> QUESTION STRING + +State 6: +## Known stack suffix: +## IDENT +## LR(1) items: +tpat -> IDENT . [ SINGLE_EQUAL DASH_ARROW ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL DASH_ARROW +-- reduce production tpat -> IDENT + +State 7: +## Known stack suffix: +## TYP_FUN tpat +## LR(1) items: +exp -> TYP_FUN tpat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On DASH_ARROW shift to state 8 +## Reductions: + +State 8: +## Known stack suffix: +## TYP_FUN tpat DASH_ARROW +## LR(1) items: +exp -> TYP_FUN tpat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 235 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 9: +## Known stack suffix: +## TYP +## LR(1) items: +exp -> TYP . tpat SINGLE_EQUAL typ IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On QUESTION shift to state 4 +-- On IDENT shift to state 6 +-- On tpat shift to state 10 +## Reductions: + +State 10: +## Known stack suffix: +## TYP tpat +## LR(1) items: +exp -> TYP tpat . SINGLE_EQUAL typ IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SINGLE_EQUAL shift to state 11 +## Reductions: + +State 11: +## Known stack suffix: +## TYP tpat SINGLE_EQUAL +## LR(1) items: +exp -> TYP tpat SINGLE_EQUAL . typ IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 33 +## Reductions: + +State 12: +## Known stack suffix: +## UNKNOWN +## LR(1) items: +typ -> UNKNOWN . INTERNAL [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On INTERNAL shift to state 13 +## Reductions: + +State 13: +## Known stack suffix: +## UNKNOWN INTERNAL +## LR(1) items: +typ -> UNKNOWN INTERNAL . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production typ -> UNKNOWN INTERNAL + +State 14: +## Known stack suffix: +## UNIT +## LR(1) items: +typ -> UNIT . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production typ -> UNIT + +State 15: +## Known stack suffix: +## STRING_TYPE +## LR(1) items: +typ -> STRING_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production typ -> STRING_TYPE + +State 16: +## Known stack suffix: +## QUESTION +## LR(1) items: +typ -> QUESTION . STRING [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING shift to state 17 +## Reductions: + +State 17: +## Known stack suffix: +## QUESTION STRING +## LR(1) items: +typ -> QUESTION STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production typ -> QUESTION STRING + +State 18: +## Known stack suffix: +## OPEN_SQUARE_BRACKET +## LR(1) items: +typ -> OPEN_SQUARE_BRACKET . typ CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 31 +## Reductions: + +State 19: +## Known stack suffix: +## OPEN_PAREN +## LR(1) items: +typ -> OPEN_PAREN . loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 23 +-- On separated_nonempty_list(COMMA,typ) shift to state 28 +-- On loption(separated_nonempty_list(COMMA,typ)) shift to state 29 +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,typ)) -> + +State 20: +## Known stack suffix: +## INT_TYPE +## LR(1) items: +typ -> INT_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production typ -> INT_TYPE + +State 21: +## Known stack suffix: +## FLOAT_TYPE +## LR(1) items: +typ -> FLOAT_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production typ -> FLOAT_TYPE + +State 22: +## Known stack suffix: +## BOOL_TYPE +## LR(1) items: +typ -> BOOL_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production typ -> BOOL_TYPE + +State 23: +## Known stack suffix: +## typ +## LR(1) items: +separated_nonempty_list(COMMA,typ) -> typ . [ CLOSE_PAREN ] +separated_nonempty_list(COMMA,typ) -> typ . COMMA separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ DASH_ARROW COMMA CLOSE_PAREN ] +## Transitions: +-- On DASH_ARROW shift to state 24 +-- On COMMA shift to state 26 +## Reductions: +-- On CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,typ) -> typ + +State 24: +## Known stack suffix: +## typ DASH_ARROW +## LR(1) items: +typ -> typ DASH_ARROW . typ [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 25 +## Reductions: + +State 25: +## Known stack suffix: +## typ DASH_ARROW typ +## LR(1) items: +typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ DASH_ARROW typ . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production typ -> typ DASH_ARROW typ + +State 26: +## Known stack suffix: +## typ COMMA +## LR(1) items: +separated_nonempty_list(COMMA,typ) -> typ COMMA . separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 23 +-- On separated_nonempty_list(COMMA,typ) shift to state 27 +## Reductions: + +State 27: +## Known stack suffix: +## typ COMMA separated_nonempty_list(COMMA,typ) +## LR(1) items: +separated_nonempty_list(COMMA,typ) -> typ COMMA separated_nonempty_list(COMMA,typ) . [ CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,typ) -> typ COMMA separated_nonempty_list(COMMA,typ) + +State 28: +## Known stack suffix: +## separated_nonempty_list(COMMA,typ) +## LR(1) items: +loption(separated_nonempty_list(COMMA,typ)) -> separated_nonempty_list(COMMA,typ) . [ CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,typ)) -> separated_nonempty_list(COMMA,typ) + +State 29: +## Known stack suffix: +## OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) +## LR(1) items: +typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On CLOSE_PAREN shift to state 30 +## Reductions: + +State 30: +## Known stack suffix: +## OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN +## LR(1) items: +typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN + +State 31: +## Known stack suffix: +## OPEN_SQUARE_BRACKET typ +## LR(1) items: +typ -> OPEN_SQUARE_BRACKET typ . CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ DASH_ARROW CLOSE_SQUARE_BRACKET ] +## Transitions: +-- On DASH_ARROW shift to state 24 +-- On CLOSE_SQUARE_BRACKET shift to state 32 +## Reductions: + +State 32: +## Known stack suffix: +## OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET +## LR(1) items: +typ -> OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production typ -> OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET + +State 33: +## Known stack suffix: +## TYP tpat SINGLE_EQUAL typ +## LR(1) items: +exp -> TYP tpat SINGLE_EQUAL typ . IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ IN DASH_ARROW ] +## Transitions: +-- On IN shift to state 34 +-- On DASH_ARROW shift to state 24 +## Reductions: + +State 34: +## Known stack suffix: +## TYP tpat SINGLE_EQUAL typ IN +## LR(1) items: +exp -> TYP tpat SINGLE_EQUAL typ IN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 234 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 35: +## Known stack suffix: +## TRUE +## LR(1) items: +exp -> TRUE . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> TRUE + +State 36: +## Known stack suffix: +## TEST +## LR(1) items: +exp -> TEST . exp END [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 232 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 37: +## Known stack suffix: +## STRING +## LR(1) items: +exp -> STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> STRING + +State 38: +## Known stack suffix: +## QUESTION +## LR(1) items: +exp -> QUESTION . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> QUESTION . STRING [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING shift to state 39 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> QUESTION + +State 39: +## Known stack suffix: +## QUESTION STRING +## LR(1) items: +exp -> QUESTION STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> QUESTION STRING + +State 40: +## Known stack suffix: +## PAUSE +## LR(1) items: +filterAction -> PAUSE . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] +## Transitions: +## Reductions: +-- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN +-- reduce production filterAction -> PAUSE + +State 41: +## Known stack suffix: +## OPEN_SQUARE_BRACKET +## LR(1) items: +exp -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On separated_nonempty_list(COMMA,exp) shift to state 187 +-- On loption(separated_nonempty_list(COMMA,exp)) shift to state 194 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 190 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: +-- On CLOSE_SQUARE_BRACKET +-- reduce production loption(separated_nonempty_list(COMMA,exp)) -> + +State 42: +## Known stack suffix: +## OPEN_PAREN +## LR(1) items: +exp -> OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> OPEN_PAREN . exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 159 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 43: +## Known stack suffix: +## NAMED_FUN +## LR(1) items: +funExp -> NAMED_FUN . IDENT pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On IDENT shift to state 44 +## Reductions: + +State 44: +## Known stack suffix: +## NAMED_FUN IDENT +## LR(1) items: +funExp -> NAMED_FUN IDENT . pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 45 +-- On TRUE shift to state 46 +-- On STRING shift to state 47 +-- On QUESTION shift to state 48 +-- On OPEN_SQUARE_BRACKET shift to state 50 +-- On OPEN_PAREN shift to state 51 +-- On INT shift to state 52 +-- On IDENT shift to state 53 +-- On FLOAT shift to state 54 +-- On FALSE shift to state 55 +-- On CONSTRUCTOR_IDENT shift to state 56 +-- On pat shift to state 82 +## Reductions: + +State 45: +## Known stack suffix: +## WILD +## LR(1) items: +pat -> WILD . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> WILD + +State 46: +## Known stack suffix: +## TRUE +## LR(1) items: +pat -> TRUE . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> TRUE + +State 47: +## Known stack suffix: +## STRING +## LR(1) items: +pat -> STRING . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> STRING + +State 48: +## Known stack suffix: +## QUESTION +## LR(1) items: +pat -> QUESTION . STRING [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> QUESTION . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 49 +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> QUESTION + +State 49: +## Known stack suffix: +## QUESTION STRING +## LR(1) items: +pat -> QUESTION STRING . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> QUESTION STRING + +State 50: +## Known stack suffix: +## OPEN_SQUARE_BRACKET +## LR(1) items: +pat -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 45 +-- On TRUE shift to state 46 +-- On STRING shift to state 47 +-- On QUESTION shift to state 48 +-- On OPEN_SQUARE_BRACKET shift to state 50 +-- On OPEN_PAREN shift to state 51 +-- On INT shift to state 52 +-- On IDENT shift to state 53 +-- On FLOAT shift to state 54 +-- On FALSE shift to state 55 +-- On CONSTRUCTOR_IDENT shift to state 56 +-- On separated_nonempty_list(COMMA,pat) shift to state 73 +-- On pat shift to state 74 +-- On loption(separated_nonempty_list(COMMA,pat)) shift to state 80 +## Reductions: +-- On CLOSE_SQUARE_BRACKET +-- reduce production loption(separated_nonempty_list(COMMA,pat)) -> + +State 51: +## Known stack suffix: +## OPEN_PAREN +## LR(1) items: +pat -> OPEN_PAREN . pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> OPEN_PAREN . pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 45 +-- On TRUE shift to state 46 +-- On STRING shift to state 47 +-- On QUESTION shift to state 48 +-- On OPEN_SQUARE_BRACKET shift to state 50 +-- On OPEN_PAREN shift to state 51 +-- On INT shift to state 52 +-- On IDENT shift to state 53 +-- On FLOAT shift to state 54 +-- On FALSE shift to state 55 +-- On CONSTRUCTOR_IDENT shift to state 56 +-- On pat shift to state 59 +## Reductions: + +State 52: +## Known stack suffix: +## INT +## LR(1) items: +pat -> INT . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> INT + +State 53: +## Known stack suffix: +## IDENT +## LR(1) items: +pat -> IDENT . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> IDENT + +State 54: +## Known stack suffix: +## FLOAT +## LR(1) items: +pat -> FLOAT . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> FLOAT + +State 55: +## Known stack suffix: +## FALSE +## LR(1) items: +pat -> FALSE . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> FALSE + +State 56: +## Known stack suffix: +## CONSTRUCTOR_IDENT +## LR(1) items: +pat -> CONSTRUCTOR_IDENT . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> CONSTRUCTOR_IDENT . TILDE typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On TILDE shift to state 57 +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> CONSTRUCTOR_IDENT + +State 57: +## Known stack suffix: +## CONSTRUCTOR_IDENT TILDE +## LR(1) items: +pat -> CONSTRUCTOR_IDENT TILDE . typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 58 +## Reductions: + +State 58: +## Known stack suffix: +## CONSTRUCTOR_IDENT TILDE typ +## LR(1) items: +pat -> CONSTRUCTOR_IDENT TILDE typ . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> CONSTRUCTOR_IDENT TILDE typ + +State 59: +## Known stack suffix: +## OPEN_PAREN pat +## LR(1) items: +pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_PAREN ] +pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_PAREN ] +pat -> OPEN_PAREN pat . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> OPEN_PAREN pat . COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_PAREN ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_PAREN ] +## Transitions: +-- On OPEN_PAREN shift to state 60 +-- On LESS_THAN shift to state 62 +-- On CONS shift to state 67 +-- On COMMA shift to state 72 +-- On COLON shift to state 69 +-- On CLOSE_PAREN shift to state 79 +## Reductions: + +State 60: +## Known stack suffix: +## pat OPEN_PAREN +## LR(1) items: +pat -> pat OPEN_PAREN . pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 45 +-- On TRUE shift to state 46 +-- On STRING shift to state 47 +-- On QUESTION shift to state 48 +-- On OPEN_SQUARE_BRACKET shift to state 50 +-- On OPEN_PAREN shift to state 51 +-- On INT shift to state 52 +-- On IDENT shift to state 53 +-- On FLOAT shift to state 54 +-- On FALSE shift to state 55 +-- On CONSTRUCTOR_IDENT shift to state 56 +-- On pat shift to state 61 +## Reductions: + +State 61: +## Known stack suffix: +## pat OPEN_PAREN pat +## LR(1) items: +pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN CONS COLON CLOSE_PAREN ] +pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN CONS COLON CLOSE_PAREN ] +pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN CONS COLON CLOSE_PAREN ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN CONS COLON CLOSE_PAREN ] +pat -> pat OPEN_PAREN pat . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On OPEN_PAREN shift to state 60 +-- On LESS_THAN shift to state 62 +-- On CONS shift to state 67 +-- On COLON shift to state 69 +-- On CLOSE_PAREN shift to state 71 +## Reductions: + +State 62: +## Known stack suffix: +## pat LESS_THAN +## LR(1) items: +pat -> pat LESS_THAN . typ EQUAL_ARROW typ GREATER_THAN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 63 +## Reductions: + +State 63: +## Known stack suffix: +## pat LESS_THAN typ +## LR(1) items: +pat -> pat LESS_THAN typ . EQUAL_ARROW typ GREATER_THAN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] +## Transitions: +-- On EQUAL_ARROW shift to state 64 +-- On DASH_ARROW shift to state 24 +## Reductions: + +State 64: +## Known stack suffix: +## pat LESS_THAN typ EQUAL_ARROW +## LR(1) items: +pat -> pat LESS_THAN typ EQUAL_ARROW . typ GREATER_THAN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 65 +## Reductions: + +State 65: +## Known stack suffix: +## pat LESS_THAN typ EQUAL_ARROW typ +## LR(1) items: +pat -> pat LESS_THAN typ EQUAL_ARROW typ . GREATER_THAN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ GREATER_THAN DASH_ARROW ] +## Transitions: +-- On GREATER_THAN shift to state 66 +-- On DASH_ARROW shift to state 24 +## Reductions: + +State 66: +## Known stack suffix: +## pat LESS_THAN typ EQUAL_ARROW typ GREATER_THAN +## LR(1) items: +pat -> pat LESS_THAN typ EQUAL_ARROW typ GREATER_THAN . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> pat LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +State 67: +## Known stack suffix: +## pat CONS +## LR(1) items: +pat -> pat CONS . pat [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 45 +-- On TRUE shift to state 46 +-- On STRING shift to state 47 +-- On QUESTION shift to state 48 +-- On OPEN_SQUARE_BRACKET shift to state 50 +-- On OPEN_PAREN shift to state 51 +-- On INT shift to state 52 +-- On IDENT shift to state 53 +-- On FLOAT shift to state 54 +-- On FALSE shift to state 55 +-- On CONSTRUCTOR_IDENT shift to state 56 +-- On pat shift to state 68 +## Reductions: + +State 68: +## Known stack suffix: +## pat CONS pat +## LR(1) items: +pat -> pat . COLON typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . CONS pat [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat CONS pat . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On OPEN_PAREN shift to state 60 +-- On COLON shift to state 69 +## Reductions: +-- On SINGLE_EQUAL LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> pat CONS pat + +State 69: +## Known stack suffix: +## pat COLON +## LR(1) items: +pat -> pat COLON . typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 70 +## Reductions: + +State 70: +## Known stack suffix: +## pat COLON typ +## LR(1) items: +pat -> pat COLON typ . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> pat COLON typ + +State 71: +## Known stack suffix: +## pat OPEN_PAREN pat CLOSE_PAREN +## LR(1) items: +pat -> pat OPEN_PAREN pat CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> pat OPEN_PAREN pat CLOSE_PAREN + +State 72: +## Known stack suffix: +## OPEN_PAREN pat COMMA +## LR(1) items: +pat -> OPEN_PAREN pat COMMA . loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 45 +-- On TRUE shift to state 46 +-- On STRING shift to state 47 +-- On QUESTION shift to state 48 +-- On OPEN_SQUARE_BRACKET shift to state 50 +-- On OPEN_PAREN shift to state 51 +-- On INT shift to state 52 +-- On IDENT shift to state 53 +-- On FLOAT shift to state 54 +-- On FALSE shift to state 55 +-- On CONSTRUCTOR_IDENT shift to state 56 +-- On separated_nonempty_list(COMMA,pat) shift to state 73 +-- On pat shift to state 74 +-- On loption(separated_nonempty_list(COMMA,pat)) shift to state 77 +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,pat)) -> + +State 73: +## Known stack suffix: +## separated_nonempty_list(COMMA,pat) +## LR(1) items: +loption(separated_nonempty_list(COMMA,pat)) -> separated_nonempty_list(COMMA,pat) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,pat)) -> separated_nonempty_list(COMMA,pat) + +State 74: +## Known stack suffix: +## pat +## LR(1) items: +pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +separated_nonempty_list(COMMA,pat) -> pat . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +separated_nonempty_list(COMMA,pat) -> pat . COMMA separated_nonempty_list(COMMA,pat) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On OPEN_PAREN shift to state 60 +-- On LESS_THAN shift to state 62 +-- On CONS shift to state 67 +-- On COMMA shift to state 75 +-- On COLON shift to state 69 +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,pat) -> pat + +State 75: +## Known stack suffix: +## pat COMMA +## LR(1) items: +separated_nonempty_list(COMMA,pat) -> pat COMMA . separated_nonempty_list(COMMA,pat) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 45 +-- On TRUE shift to state 46 +-- On STRING shift to state 47 +-- On QUESTION shift to state 48 +-- On OPEN_SQUARE_BRACKET shift to state 50 +-- On OPEN_PAREN shift to state 51 +-- On INT shift to state 52 +-- On IDENT shift to state 53 +-- On FLOAT shift to state 54 +-- On FALSE shift to state 55 +-- On CONSTRUCTOR_IDENT shift to state 56 +-- On separated_nonempty_list(COMMA,pat) shift to state 76 +-- On pat shift to state 74 +## Reductions: + +State 76: +## Known stack suffix: +## pat COMMA separated_nonempty_list(COMMA,pat) +## LR(1) items: +separated_nonempty_list(COMMA,pat) -> pat COMMA separated_nonempty_list(COMMA,pat) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,pat) -> pat COMMA separated_nonempty_list(COMMA,pat) + +State 77: +## Known stack suffix: +## OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) +## LR(1) items: +pat -> OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On CLOSE_PAREN shift to state 78 +## Reductions: + +State 78: +## Known stack suffix: +## OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN +## LR(1) items: +pat -> OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN + +State 79: +## Known stack suffix: +## OPEN_PAREN pat CLOSE_PAREN +## LR(1) items: +pat -> OPEN_PAREN pat CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> OPEN_PAREN pat CLOSE_PAREN + +State 80: +## Known stack suffix: +## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) +## LR(1) items: +pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) . CLOSE_SQUARE_BRACKET [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On CLOSE_SQUARE_BRACKET shift to state 81 +## Reductions: + +State 81: +## Known stack suffix: +## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET +## LR(1) items: +pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET + +State 82: +## Known stack suffix: +## NAMED_FUN IDENT pat +## LR(1) items: +funExp -> NAMED_FUN IDENT pat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] +pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] +pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] +## Transitions: +-- On OPEN_PAREN shift to state 60 +-- On LESS_THAN shift to state 62 +-- On DASH_ARROW shift to state 83 +-- On CONS shift to state 67 +-- On COLON shift to state 69 +## Reductions: + +State 83: +## Known stack suffix: +## NAMED_FUN IDENT pat DASH_ARROW +## LR(1) items: +funExp -> NAMED_FUN IDENT pat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 231 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 84: +## Known stack suffix: +## MINUS +## LR(1) items: +unExp -> MINUS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 230 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 85: +## Known stack suffix: +## L_NOT +## LR(1) items: +unExp -> L_NOT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 229 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 86: +## Known stack suffix: +## LET +## LR(1) items: +exp -> LET . pat SINGLE_EQUAL exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 45 +-- On TRUE shift to state 46 +-- On STRING shift to state 47 +-- On QUESTION shift to state 48 +-- On OPEN_SQUARE_BRACKET shift to state 50 +-- On OPEN_PAREN shift to state 51 +-- On INT shift to state 52 +-- On IDENT shift to state 53 +-- On FLOAT shift to state 54 +-- On FALSE shift to state 55 +-- On CONSTRUCTOR_IDENT shift to state 56 +-- On pat shift to state 87 +## Reductions: + +State 87: +## Known stack suffix: +## LET pat +## LR(1) items: +exp -> LET pat . SINGLE_EQUAL exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +pat -> pat . COLON typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN CONS COLON ] +pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN CONS COLON ] +pat -> pat . CONS pat [ SINGLE_EQUAL OPEN_PAREN LESS_THAN CONS COLON ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN CONS COLON ] +## Transitions: +-- On SINGLE_EQUAL shift to state 88 +-- On OPEN_PAREN shift to state 60 +-- On LESS_THAN shift to state 62 +-- On CONS shift to state 67 +-- On COLON shift to state 69 +## Reductions: + +State 88: +## Known stack suffix: +## LET pat SINGLE_EQUAL +## LR(1) items: +exp -> LET pat SINGLE_EQUAL . exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 226 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 89: +## Known stack suffix: +## LESS_THAN +## LR(1) items: +exp -> LESS_THAN . LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On LESS_THAN shift to state 90 +## Reductions: + +State 90: +## Known stack suffix: +## LESS_THAN LESS_THAN +## LR(1) items: +exp -> LESS_THAN LESS_THAN . exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 221 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 91: +## Known stack suffix: +## INT +## LR(1) items: +exp -> INT . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> INT + +State 92: +## Known stack suffix: +## IF +## LR(1) items: +exp -> IF . exp THEN exp ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 216 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 93: +## Known stack suffix: +## IDENT +## LR(1) items: +exp -> IDENT . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> IDENT + +State 94: +## Known stack suffix: +## HIDE +## LR(1) items: +filterAction -> HIDE . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] +## Transitions: +## Reductions: +-- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN +-- reduce production filterAction -> HIDE + +State 95: +## Known stack suffix: +## FUN +## LR(1) items: +funExp -> FUN . pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 45 +-- On TRUE shift to state 46 +-- On STRING shift to state 47 +-- On QUESTION shift to state 48 +-- On OPEN_SQUARE_BRACKET shift to state 50 +-- On OPEN_PAREN shift to state 51 +-- On INT shift to state 52 +-- On IDENT shift to state 53 +-- On FLOAT shift to state 54 +-- On FALSE shift to state 55 +-- On CONSTRUCTOR_IDENT shift to state 56 +-- On pat shift to state 96 +## Reductions: + +State 96: +## Known stack suffix: +## FUN pat +## LR(1) items: +funExp -> FUN pat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] +pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] +pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] +## Transitions: +-- On OPEN_PAREN shift to state 60 +-- On LESS_THAN shift to state 62 +-- On DASH_ARROW shift to state 97 +-- On CONS shift to state 67 +-- On COLON shift to state 69 +## Reductions: + +State 97: +## Known stack suffix: +## FUN pat DASH_ARROW +## LR(1) items: +funExp -> FUN pat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 215 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 98: +## Known stack suffix: +## FLOAT +## LR(1) items: +exp -> FLOAT . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> FLOAT + +State 99: +## Known stack suffix: +## FIX +## LR(1) items: +exp -> FIX . pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 45 +-- On TRUE shift to state 46 +-- On STRING shift to state 47 +-- On QUESTION shift to state 48 +-- On OPEN_SQUARE_BRACKET shift to state 50 +-- On OPEN_PAREN shift to state 51 +-- On INT shift to state 52 +-- On IDENT shift to state 53 +-- On FLOAT shift to state 54 +-- On FALSE shift to state 55 +-- On CONSTRUCTOR_IDENT shift to state 56 +-- On pat shift to state 100 +## Reductions: + +State 100: +## Known stack suffix: +## FIX pat +## LR(1) items: +exp -> FIX pat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] +pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] +pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] +## Transitions: +-- On OPEN_PAREN shift to state 60 +-- On LESS_THAN shift to state 62 +-- On DASH_ARROW shift to state 101 +-- On CONS shift to state 67 +-- On COLON shift to state 69 +## Reductions: + +State 101: +## Known stack suffix: +## FIX pat DASH_ARROW +## LR(1) items: +exp -> FIX pat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 214 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 102: +## Known stack suffix: +## FALSE +## LR(1) items: +exp -> FALSE . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> FALSE + +State 103: +## Known stack suffix: +## EVAL +## LR(1) items: +filterAction -> EVAL . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] +## Transitions: +## Reductions: +-- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN +-- reduce production filterAction -> EVAL + +State 104: +## Known stack suffix: +## DOLLAR_SIGN +## LR(1) items: +unExp -> DOLLAR_SIGN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 213 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 105: +## Known stack suffix: +## DEBUG +## LR(1) items: +filterAction -> DEBUG . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] +## Transitions: +## Reductions: +-- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN +-- reduce production filterAction -> DEBUG + +State 106: +## Known stack suffix: +## CONSTRUCTOR_IDENT +## LR(1) items: +exp -> CONSTRUCTOR_IDENT . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> CONSTRUCTOR_IDENT . TILDE typ [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TILDE shift to state 107 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> CONSTRUCTOR_IDENT + +State 107: +## Known stack suffix: +## CONSTRUCTOR_IDENT TILDE +## LR(1) items: +exp -> CONSTRUCTOR_IDENT TILDE . typ [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 108 +## Reductions: + +State 108: +## Known stack suffix: +## CONSTRUCTOR_IDENT TILDE typ +## LR(1) items: +exp -> CONSTRUCTOR_IDENT TILDE typ . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On DASH_ARROW shift to state 24 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> CONSTRUCTOR_IDENT TILDE typ + +State 109: +## Known stack suffix: +## CASE +## LR(1) items: +case -> CASE . exp list(rul) END [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 204 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 110: +## Known stack suffix: +## BUILTIN +## LR(1) items: +exp -> BUILTIN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> BUILTIN + +State 111: +## Known stack suffix: +## unExp +## LR(1) items: +exp -> unExp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> unExp + +State 112: +## Known stack suffix: +## funExp +## LR(1) items: +exp -> funExp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> funExp + +State 113: +## Known stack suffix: +## filterAction +## LR(1) items: +exp -> filterAction . exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 114 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 114: +## Known stack suffix: +## filterAction exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> filterAction exp . IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On IN shift to state 202 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: + +State 115: +## Known stack suffix: +## exp TIMES_FLOAT +## LR(1) items: +binExp -> exp TIMES_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 116 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 116: +## Known stack suffix: +## exp TIMES_FLOAT exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp TIMES_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On OPEN_PAREN shift to state 131 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp TIMES_FLOAT exp + +State 117: +## Known stack suffix: +## exp SEMI_COLON +## LR(1) items: +exp -> exp SEMI_COLON . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 118 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 118: +## Known stack suffix: +## exp SEMI_COLON exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp SEMI_COLON exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> exp SEMI_COLON exp + +State 119: +## Known stack suffix: +## exp L_OR +## LR(1) items: +binExp -> exp L_OR . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 120 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 120: +## Known stack suffix: +## exp L_OR exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp L_OR exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production binExp -> exp L_OR exp + +State 121: +## Known stack suffix: +## case +## LR(1) items: +exp -> case . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> case + +State 122: +## Known stack suffix: +## binExp +## LR(1) items: +exp -> binExp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> binExp + +State 123: +## Known stack suffix: +## exp L_AND +## LR(1) items: +binExp -> exp L_AND . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 124 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 124: +## Known stack suffix: +## exp L_AND exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp L_AND exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production binExp -> exp L_AND exp + +State 125: +## Known stack suffix: +## exp QUESTION +## LR(1) items: +exp -> exp QUESTION . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On LESS_THAN shift to state 126 +## Reductions: + +State 126: +## Known stack suffix: +## exp QUESTION LESS_THAN +## LR(1) items: +exp -> exp QUESTION LESS_THAN . typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 127 +## Reductions: + +State 127: +## Known stack suffix: +## exp QUESTION LESS_THAN typ +## LR(1) items: +exp -> exp QUESTION LESS_THAN typ . EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] +## Transitions: +-- On EQUAL_ARROW shift to state 128 +-- On DASH_ARROW shift to state 24 +## Reductions: + +State 128: +## Known stack suffix: +## exp QUESTION LESS_THAN typ EQUAL_ARROW +## LR(1) items: +exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW . typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 129 +## Reductions: + +State 129: +## Known stack suffix: +## exp QUESTION LESS_THAN typ EQUAL_ARROW typ +## LR(1) items: +exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW typ . GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ GREATER_THAN DASH_ARROW ] +## Transitions: +-- On GREATER_THAN shift to state 130 +-- On DASH_ARROW shift to state 24 +## Reductions: + +State 130: +## Known stack suffix: +## exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN +## LR(1) items: +exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +State 131: +## Known stack suffix: +## exp OPEN_PAREN +## LR(1) items: +exp -> exp OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 132 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 132: +## Known stack suffix: +## exp OPEN_PAREN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp OPEN_PAREN exp . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On CLOSE_PAREN shift to state 201 +-- On AT_SYMBOL shift to state 139 +## Reductions: + +State 133: +## Known stack suffix: +## exp TIMES +## LR(1) items: +binExp -> exp TIMES . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 134 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 134: +## Known stack suffix: +## exp TIMES exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp TIMES exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On PLUS_FLOAT shift to state 144 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On MINUS_FLOAT shift to state 148 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DIVIDE_FLOAT shift to state 170 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp TIMES exp + +State 135: +## Known stack suffix: +## exp POWER_FLOAT +## LR(1) items: +binExp -> exp POWER_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 136 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 136: +## Known stack suffix: +## exp POWER_FLOAT exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp POWER_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On OPEN_PAREN shift to state 131 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp POWER_FLOAT exp + +State 137: +## Known stack suffix: +## exp CONS +## LR(1) items: +exp -> exp CONS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 138 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 138: +## Known stack suffix: +## exp CONS exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp CONS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On OPEN_PAREN shift to state 131 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> exp CONS exp + +State 139: +## Known stack suffix: +## exp AT_SYMBOL +## LR(1) items: +exp -> exp AT_SYMBOL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp AT_SYMBOL . LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 140 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 143 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 140: +## Known stack suffix: +## exp AT_SYMBOL LESS_THAN +## LR(1) items: +exp -> exp AT_SYMBOL LESS_THAN . typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> LESS_THAN . LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On LESS_THAN shift to state 90 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 141 +## Reductions: + +State 141: +## Known stack suffix: +## exp AT_SYMBOL LESS_THAN typ +## LR(1) items: +exp -> exp AT_SYMBOL LESS_THAN typ . GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ GREATER_THAN DASH_ARROW ] +## Transitions: +-- On GREATER_THAN shift to state 142 +-- On DASH_ARROW shift to state 24 +## Reductions: + +State 142: +## Known stack suffix: +## exp AT_SYMBOL LESS_THAN typ GREATER_THAN +## LR(1) items: +exp -> exp AT_SYMBOL LESS_THAN typ GREATER_THAN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> exp AT_SYMBOL LESS_THAN typ GREATER_THAN + +State 143: +## Known stack suffix: +## exp AT_SYMBOL exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp AT_SYMBOL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> exp AT_SYMBOL exp + +State 144: +## Known stack suffix: +## exp PLUS_FLOAT +## LR(1) items: +binExp -> exp PLUS_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 145 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 145: +## Known stack suffix: +## exp PLUS_FLOAT exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp PLUS_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On OPEN_PAREN shift to state 131 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp PLUS_FLOAT exp + +State 146: +## Known stack suffix: +## exp NOT_EQUAL_FLOAT +## LR(1) items: +binExp -> exp NOT_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 147 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 147: +## Known stack suffix: +## exp NOT_EQUAL_FLOAT exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp NOT_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On OPEN_PAREN shift to state 131 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp NOT_EQUAL_FLOAT exp + +State 148: +## Known stack suffix: +## exp MINUS_FLOAT +## LR(1) items: +binExp -> exp MINUS_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 149 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 149: +## Known stack suffix: +## exp MINUS_FLOAT exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp MINUS_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On OPEN_PAREN shift to state 131 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp MINUS_FLOAT exp + +State 150: +## Known stack suffix: +## exp LESS_THAN_FLOAT +## LR(1) items: +binExp -> exp LESS_THAN_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 151 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 151: +## Known stack suffix: +## exp LESS_THAN_FLOAT exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp LESS_THAN_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On OPEN_PAREN shift to state 131 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp LESS_THAN_FLOAT exp + +State 152: +## Known stack suffix: +## exp LESS_THAN_EQUAL_FLOAT +## LR(1) items: +binExp -> exp LESS_THAN_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 153 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 153: +## Known stack suffix: +## exp LESS_THAN_EQUAL_FLOAT exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp LESS_THAN_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On OPEN_PAREN shift to state 131 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp LESS_THAN_EQUAL_FLOAT exp + +State 154: +## Known stack suffix: +## exp LESS_THAN +## LR(1) items: +binExp -> exp LESS_THAN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp LESS_THAN . typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING_TYPE shift to state 15 +-- On STRING shift to state 37 +-- On QUESTION shift to state 155 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 157 +-- On OPEN_PAREN shift to state 158 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT_TYPE shift to state 20 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT_TYPE shift to state 21 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On BOOL_TYPE shift to state 22 +-- On unExp shift to state 111 +-- On typ shift to state 196 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 200 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 155: +## Known stack suffix: +## QUESTION +## LR(1) items: +exp -> QUESTION . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> QUESTION . STRING [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> QUESTION . STRING [ EQUAL_ARROW DASH_ARROW COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 156 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> QUESTION + +State 156: +## Known stack suffix: +## QUESTION STRING +## LR(1) items: +exp -> QUESTION STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> QUESTION STRING . [ EQUAL_ARROW DASH_ARROW COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> QUESTION STRING +-- On EQUAL_ARROW DASH_ARROW COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production typ -> QUESTION STRING +** Conflict on COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN + +State 157: +## Known stack suffix: +## OPEN_SQUARE_BRACKET +## LR(1) items: +exp -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> OPEN_SQUARE_BRACKET . typ CLOSE_SQUARE_BRACKET [ EQUAL_ARROW DASH_ARROW COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 1 +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING_TYPE shift to state 15 +-- On STRING shift to state 37 +-- On QUESTION shift to state 155 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 157 +-- On OPEN_PAREN shift to state 158 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT_TYPE shift to state 20 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT_TYPE shift to state 21 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On BOOL_TYPE shift to state 22 +-- On unExp shift to state 111 +-- On typ shift to state 31 +-- On separated_nonempty_list(COMMA,exp) shift to state 187 +-- On loption(separated_nonempty_list(COMMA,exp)) shift to state 194 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 190 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: +-- On CLOSE_SQUARE_BRACKET +-- reduce production loption(separated_nonempty_list(COMMA,exp)) -> + +State 158: +## Known stack suffix: +## OPEN_PAREN +## LR(1) items: +exp -> OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> OPEN_PAREN . exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> OPEN_PAREN . loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ EQUAL_ARROW DASH_ARROW COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 1 +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING_TYPE shift to state 15 +-- On STRING shift to state 37 +-- On QUESTION shift to state 155 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 157 +-- On OPEN_PAREN shift to state 158 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT_TYPE shift to state 20 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT_TYPE shift to state 21 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On BOOL_TYPE shift to state 22 +-- On unExp shift to state 111 +-- On typ shift to state 23 +-- On separated_nonempty_list(COMMA,typ) shift to state 28 +-- On loption(separated_nonempty_list(COMMA,typ)) shift to state 29 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 159 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,typ)) -> + +State 159: +## Known stack suffix: +## OPEN_PAREN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> OPEN_PAREN exp . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> OPEN_PAREN exp . COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On COMMA shift to state 186 +-- On CLOSE_PAREN shift to state 193 +-- On AT_SYMBOL shift to state 139 +## Reductions: + +State 160: +## Known stack suffix: +## exp POWER +## LR(1) items: +binExp -> exp POWER . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 161 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 161: +## Known stack suffix: +## exp POWER exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp POWER exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On PLUS_FLOAT shift to state 144 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On MINUS_FLOAT shift to state 148 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DIVIDE_FLOAT shift to state 170 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp POWER exp + +State 162: +## Known stack suffix: +## exp GREATER_THAN_FLOAT +## LR(1) items: +binExp -> exp GREATER_THAN_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 163 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 163: +## Known stack suffix: +## exp GREATER_THAN_FLOAT exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp GREATER_THAN_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On OPEN_PAREN shift to state 131 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp GREATER_THAN_FLOAT exp + +State 164: +## Known stack suffix: +## exp GREATER_THAN_EQUAL_FLOAT +## LR(1) items: +binExp -> exp GREATER_THAN_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 165 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 165: +## Known stack suffix: +## exp GREATER_THAN_EQUAL_FLOAT exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp GREATER_THAN_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On OPEN_PAREN shift to state 131 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp GREATER_THAN_EQUAL_FLOAT exp + +State 166: +## Known stack suffix: +## exp GREATER_THAN +## LR(1) items: +binExp -> exp GREATER_THAN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 167 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 167: +## Known stack suffix: +## exp GREATER_THAN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp GREATER_THAN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On PLUS_FLOAT shift to state 144 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On MINUS_FLOAT shift to state 148 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DIVIDE_FLOAT shift to state 170 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp GREATER_THAN exp + +State 168: +## Known stack suffix: +## exp DOUBLE_EQUAL_FLOAT +## LR(1) items: +binExp -> exp DOUBLE_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 169 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 169: +## Known stack suffix: +## exp DOUBLE_EQUAL_FLOAT exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp DOUBLE_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On OPEN_PAREN shift to state 131 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp DOUBLE_EQUAL_FLOAT exp + +State 170: +## Known stack suffix: +## exp DIVIDE_FLOAT +## LR(1) items: +binExp -> exp DIVIDE_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 171 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 171: +## Known stack suffix: +## exp DIVIDE_FLOAT exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp DIVIDE_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On OPEN_PAREN shift to state 131 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp DIVIDE_FLOAT exp + +State 172: +## Known stack suffix: +## exp PLUS +## LR(1) items: +binExp -> exp PLUS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 173 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 173: +## Known stack suffix: +## exp PLUS exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp PLUS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On PLUS_FLOAT shift to state 144 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On MINUS_FLOAT shift to state 148 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DIVIDE_FLOAT shift to state 170 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp PLUS exp + +State 174: +## Known stack suffix: +## exp NOT_EQUAL +## LR(1) items: +binExp -> exp NOT_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 175 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 175: +## Known stack suffix: +## exp NOT_EQUAL exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp NOT_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On PLUS_FLOAT shift to state 144 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On MINUS_FLOAT shift to state 148 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DIVIDE_FLOAT shift to state 170 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp NOT_EQUAL exp + +State 176: +## Known stack suffix: +## exp MINUS +## LR(1) items: +binExp -> exp MINUS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 177 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 177: +## Known stack suffix: +## exp MINUS exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp MINUS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On PLUS_FLOAT shift to state 144 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On MINUS_FLOAT shift to state 148 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DIVIDE_FLOAT shift to state 170 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp MINUS exp + +State 178: +## Known stack suffix: +## exp LESS_THAN_EQUAL +## LR(1) items: +binExp -> exp LESS_THAN_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 179 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 179: +## Known stack suffix: +## exp LESS_THAN_EQUAL exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp LESS_THAN_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On PLUS_FLOAT shift to state 144 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On MINUS_FLOAT shift to state 148 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DIVIDE_FLOAT shift to state 170 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp LESS_THAN_EQUAL exp + +State 180: +## Known stack suffix: +## exp GREATER_THAN_EQUAL +## LR(1) items: +binExp -> exp GREATER_THAN_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 181 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 181: +## Known stack suffix: +## exp GREATER_THAN_EQUAL exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp GREATER_THAN_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On PLUS_FLOAT shift to state 144 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On MINUS_FLOAT shift to state 148 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DIVIDE_FLOAT shift to state 170 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp GREATER_THAN_EQUAL exp + +State 182: +## Known stack suffix: +## exp DOUBLE_EQUAL +## LR(1) items: +binExp -> exp DOUBLE_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 183 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 183: +## Known stack suffix: +## exp DOUBLE_EQUAL exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp DOUBLE_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On PLUS_FLOAT shift to state 144 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On MINUS_FLOAT shift to state 148 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DIVIDE_FLOAT shift to state 170 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp DOUBLE_EQUAL exp + +State 184: +## Known stack suffix: +## exp DIVIDE +## LR(1) items: +binExp -> exp DIVIDE . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 185 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 185: +## Known stack suffix: +## exp DIVIDE exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp DIVIDE exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On PLUS_FLOAT shift to state 144 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On MINUS_FLOAT shift to state 148 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DIVIDE_FLOAT shift to state 170 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp DIVIDE exp + +State 186: +## Known stack suffix: +## OPEN_PAREN exp COMMA +## LR(1) items: +exp -> OPEN_PAREN exp COMMA . loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On separated_nonempty_list(COMMA,exp) shift to state 187 +-- On loption(separated_nonempty_list(COMMA,exp)) shift to state 188 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 190 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,exp)) -> + +State 187: +## Known stack suffix: +## separated_nonempty_list(COMMA,exp) +## LR(1) items: +loption(separated_nonempty_list(COMMA,exp)) -> separated_nonempty_list(COMMA,exp) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,exp)) -> separated_nonempty_list(COMMA,exp) + +State 188: +## Known stack suffix: +## OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) +## LR(1) items: +exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On CLOSE_PAREN shift to state 189 +## Reductions: + +State 189: +## Known stack suffix: +## OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN +## LR(1) items: +exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN + +State 190: +## Known stack suffix: +## exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +separated_nonempty_list(COMMA,exp) -> exp . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +separated_nonempty_list(COMMA,exp) -> exp . COMMA separated_nonempty_list(COMMA,exp) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On COMMA shift to state 191 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,exp) -> exp + +State 191: +## Known stack suffix: +## exp COMMA +## LR(1) items: +separated_nonempty_list(COMMA,exp) -> exp COMMA . separated_nonempty_list(COMMA,exp) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On separated_nonempty_list(COMMA,exp) shift to state 192 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 190 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 192: +## Known stack suffix: +## exp COMMA separated_nonempty_list(COMMA,exp) +## LR(1) items: +separated_nonempty_list(COMMA,exp) -> exp COMMA separated_nonempty_list(COMMA,exp) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,exp) -> exp COMMA separated_nonempty_list(COMMA,exp) + +State 193: +## Known stack suffix: +## OPEN_PAREN exp CLOSE_PAREN +## LR(1) items: +exp -> OPEN_PAREN exp CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> OPEN_PAREN exp CLOSE_PAREN + +State 194: +## Known stack suffix: +## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) +## LR(1) items: +exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) . CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On CLOSE_SQUARE_BRACKET shift to state 195 +## Reductions: + +State 195: +## Known stack suffix: +## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET +## LR(1) items: +exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET + +State 196: +## Known stack suffix: +## exp LESS_THAN typ +## LR(1) items: +exp -> exp LESS_THAN typ . EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] +## Transitions: +-- On EQUAL_ARROW shift to state 197 +-- On DASH_ARROW shift to state 24 +## Reductions: + +State 197: +## Known stack suffix: +## exp LESS_THAN typ EQUAL_ARROW +## LR(1) items: +exp -> exp LESS_THAN typ EQUAL_ARROW . typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 12 +-- On UNIT shift to state 14 +-- On STRING_TYPE shift to state 15 +-- On QUESTION shift to state 16 +-- On OPEN_SQUARE_BRACKET shift to state 18 +-- On OPEN_PAREN shift to state 19 +-- On INT_TYPE shift to state 20 +-- On FLOAT_TYPE shift to state 21 +-- On BOOL_TYPE shift to state 22 +-- On typ shift to state 198 +## Reductions: + +State 198: +## Known stack suffix: +## exp LESS_THAN typ EQUAL_ARROW typ +## LR(1) items: +exp -> exp LESS_THAN typ EQUAL_ARROW typ . GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ GREATER_THAN DASH_ARROW ] +## Transitions: +-- On GREATER_THAN shift to state 199 +-- On DASH_ARROW shift to state 24 +## Reductions: + +State 199: +## Known stack suffix: +## exp LESS_THAN typ EQUAL_ARROW typ GREATER_THAN +## LR(1) items: +exp -> exp LESS_THAN typ EQUAL_ARROW typ GREATER_THAN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> exp LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + +State 200: +## Known stack suffix: +## exp LESS_THAN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp LESS_THAN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On PLUS_FLOAT shift to state 144 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On MINUS_FLOAT shift to state 148 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DIVIDE_FLOAT shift to state 170 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp LESS_THAN exp + +State 201: +## Known stack suffix: +## exp OPEN_PAREN exp CLOSE_PAREN +## LR(1) items: +exp -> exp OPEN_PAREN exp CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> exp OPEN_PAREN exp CLOSE_PAREN + +State 202: +## Known stack suffix: +## filterAction exp IN +## LR(1) items: +exp -> filterAction exp IN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 203 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 203: +## Known stack suffix: +## filterAction exp IN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> filterAction exp IN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> filterAction exp IN exp + +State 204: +## Known stack suffix: +## CASE exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +case -> CASE exp . list(rul) END [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +## Transitions: +-- On TURNSTILE shift to state 205 +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +-- On rul shift to state 209 +-- On list(rul) shift to state 211 +## Reductions: +-- On END +-- reduce production list(rul) -> + +State 205: +## Known stack suffix: +## TURNSTILE +## LR(1) items: +rul -> TURNSTILE . pat EQUAL_ARROW exp [ TURNSTILE END ] +## Transitions: +-- On WILD shift to state 45 +-- On TRUE shift to state 46 +-- On STRING shift to state 47 +-- On QUESTION shift to state 48 +-- On OPEN_SQUARE_BRACKET shift to state 50 +-- On OPEN_PAREN shift to state 51 +-- On INT shift to state 52 +-- On IDENT shift to state 53 +-- On FLOAT shift to state 54 +-- On FALSE shift to state 55 +-- On CONSTRUCTOR_IDENT shift to state 56 +-- On pat shift to state 206 +## Reductions: + +State 206: +## Known stack suffix: +## TURNSTILE pat +## LR(1) items: +pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN EQUAL_ARROW CONS COLON ] +pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN EQUAL_ARROW CONS COLON ] +pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN EQUAL_ARROW CONS COLON ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN EQUAL_ARROW CONS COLON ] +rul -> TURNSTILE pat . EQUAL_ARROW exp [ TURNSTILE END ] +## Transitions: +-- On OPEN_PAREN shift to state 60 +-- On LESS_THAN shift to state 62 +-- On EQUAL_ARROW shift to state 207 +-- On CONS shift to state 67 +-- On COLON shift to state 69 +## Reductions: + +State 207: +## Known stack suffix: +## TURNSTILE pat EQUAL_ARROW +## LR(1) items: +rul -> TURNSTILE pat EQUAL_ARROW . exp [ TURNSTILE END ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 208 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 208: +## Known stack suffix: +## TURNSTILE pat EQUAL_ARROW exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +rul -> TURNSTILE pat EQUAL_ARROW exp . [ TURNSTILE END ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE END +-- reduce production rul -> TURNSTILE pat EQUAL_ARROW exp + +State 209: +## Known stack suffix: +## rul +## LR(1) items: +list(rul) -> rul . list(rul) [ END ] +## Transitions: +-- On TURNSTILE shift to state 205 +-- On rul shift to state 209 +-- On list(rul) shift to state 210 +## Reductions: +-- On END +-- reduce production list(rul) -> + +State 210: +## Known stack suffix: +## rul list(rul) +## LR(1) items: +list(rul) -> rul list(rul) . [ END ] +## Transitions: +## Reductions: +-- On END +-- reduce production list(rul) -> rul list(rul) + +State 211: +## Known stack suffix: +## CASE exp list(rul) +## LR(1) items: +case -> CASE exp list(rul) . END [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On END shift to state 212 +## Reductions: + +State 212: +## Known stack suffix: +## CASE exp list(rul) END +## LR(1) items: +case -> CASE exp list(rul) END . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production case -> CASE exp list(rul) END + +State 213: +## Known stack suffix: +## DOLLAR_SIGN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +unExp -> DOLLAR_SIGN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production unExp -> DOLLAR_SIGN exp + +State 214: +## Known stack suffix: +## FIX pat DASH_ARROW exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> FIX pat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> FIX pat DASH_ARROW exp + +State 215: +## Known stack suffix: +## FUN pat DASH_ARROW exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +funExp -> FUN pat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production funExp -> FUN pat DASH_ARROW exp + +State 216: +## Known stack suffix: +## IF exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> IF exp . THEN exp ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On THEN shift to state 217 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: + +State 217: +## Known stack suffix: +## IF exp THEN +## LR(1) items: +exp -> IF exp THEN . exp ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 218 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 218: +## Known stack suffix: +## IF exp THEN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> IF exp THEN exp . ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On ELSE shift to state 219 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: + +State 219: +## Known stack suffix: +## IF exp THEN exp ELSE +## LR(1) items: +exp -> IF exp THEN exp ELSE . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 220 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 220: +## Known stack suffix: +## IF exp THEN exp ELSE exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> IF exp THEN exp ELSE exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> IF exp THEN exp ELSE exp + +State 221: +## Known stack suffix: +## LESS_THAN LESS_THAN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> LESS_THAN LESS_THAN exp . QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 222 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: + +State 222: +## Known stack suffix: +## LESS_THAN LESS_THAN exp QUESTION +## LR(1) items: +exp -> exp QUESTION . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> LESS_THAN LESS_THAN exp QUESTION . SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEXP_STRING shift to state 223 +-- On LESS_THAN shift to state 126 +## Reductions: + +State 223: +## Known stack suffix: +## LESS_THAN LESS_THAN exp QUESTION SEXP_STRING +## LR(1) items: +exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING . GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On GREATER_THAN shift to state 224 +## Reductions: + +State 224: +## Known stack suffix: +## LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN +## LR(1) items: +exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN . GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On GREATER_THAN shift to state 225 +## Reductions: + +State 225: +## Known stack suffix: +## LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN +## LR(1) items: +exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN + +State 226: +## Known stack suffix: +## LET pat SINGLE_EQUAL exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> LET pat SINGLE_EQUAL exp . IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On IN shift to state 227 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: + +State 227: +## Known stack suffix: +## LET pat SINGLE_EQUAL exp IN +## LR(1) items: +exp -> LET pat SINGLE_EQUAL exp IN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 9 +-- On TRUE shift to state 35 +-- On TEST shift to state 36 +-- On STRING shift to state 37 +-- On QUESTION shift to state 38 +-- On PAUSE shift to state 40 +-- On OPEN_SQUARE_BRACKET shift to state 41 +-- On OPEN_PAREN shift to state 42 +-- On NAMED_FUN shift to state 43 +-- On MINUS shift to state 84 +-- On L_NOT shift to state 85 +-- On LET shift to state 86 +-- On LESS_THAN shift to state 89 +-- On INT shift to state 91 +-- On IF shift to state 92 +-- On IDENT shift to state 93 +-- On HIDE shift to state 94 +-- On FUN shift to state 95 +-- On FLOAT shift to state 98 +-- On FIX shift to state 99 +-- On FALSE shift to state 102 +-- On EVAL shift to state 103 +-- On DOLLAR_SIGN shift to state 104 +-- On DEBUG shift to state 105 +-- On CONSTRUCTOR_IDENT shift to state 106 +-- On CASE shift to state 109 +-- On BUILTIN shift to state 110 +-- On unExp shift to state 111 +-- On funExp shift to state 112 +-- On filterAction shift to state 113 +-- On exp shift to state 228 +-- On case shift to state 121 +-- On binExp shift to state 122 +## Reductions: + +State 228: +## Known stack suffix: +## LET pat SINGLE_EQUAL exp IN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> LET pat SINGLE_EQUAL exp IN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> LET pat SINGLE_EQUAL exp IN exp + +State 229: +## Known stack suffix: +## L_NOT exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +unExp -> L_NOT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production unExp -> L_NOT exp + +State 230: +## Known stack suffix: +## MINUS exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +unExp -> MINUS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On PLUS_FLOAT shift to state 144 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On MINUS_FLOAT shift to state 148 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DIVIDE_FLOAT shift to state 170 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production unExp -> MINUS exp + +State 231: +## Known stack suffix: +## NAMED_FUN IDENT pat DASH_ARROW exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +funExp -> NAMED_FUN IDENT pat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production funExp -> NAMED_FUN IDENT pat DASH_ARROW exp + +State 232: +## Known stack suffix: +## TEST exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> TEST exp . END [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On END shift to state 233 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: + +State 233: +## Known stack suffix: +## TEST exp END +## LR(1) items: +exp -> TEST exp END . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> TEST exp END + +State 234: +## Known stack suffix: +## TYP tpat SINGLE_EQUAL typ IN exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> TYP tpat SINGLE_EQUAL typ IN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> TYP tpat SINGLE_EQUAL typ IN exp + +State 235: +## Known stack suffix: +## TYP_FUN tpat DASH_ARROW exp +## LR(1) items: +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> TYP_FUN tpat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: +-- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> TYP_FUN tpat DASH_ARROW exp + +State 236: +## Known stack suffix: +## program +## LR(1) items: +program' -> program . [ # ] +## Transitions: +## Reductions: +-- On # +-- accept program + +State 237: +## Known stack suffix: +## exp +## LR(1) items: +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +program -> exp . EOF [ # ] +## Transitions: +-- On TIMES_FLOAT shift to state 115 +-- On TIMES shift to state 133 +-- On SEMI_COLON shift to state 117 +-- On QUESTION shift to state 125 +-- On POWER_FLOAT shift to state 135 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 144 +-- On PLUS shift to state 172 +-- On OPEN_PAREN shift to state 131 +-- On NOT_EQUAL_FLOAT shift to state 146 +-- On NOT_EQUAL shift to state 174 +-- On MINUS_FLOAT shift to state 148 +-- On MINUS shift to state 176 +-- On L_OR shift to state 119 +-- On L_AND shift to state 123 +-- On LESS_THAN_FLOAT shift to state 150 +-- On LESS_THAN_EQUAL_FLOAT shift to state 152 +-- On LESS_THAN_EQUAL shift to state 178 +-- On LESS_THAN shift to state 154 +-- On GREATER_THAN_FLOAT shift to state 162 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 164 +-- On GREATER_THAN_EQUAL shift to state 180 +-- On GREATER_THAN shift to state 166 +-- On EOF shift to state 238 +-- On DOUBLE_EQUAL_FLOAT shift to state 168 +-- On DOUBLE_EQUAL shift to state 182 +-- On DIVIDE_FLOAT shift to state 170 +-- On DIVIDE shift to state 184 +-- On CONS shift to state 137 +-- On AT_SYMBOL shift to state 139 +## Reductions: + +State 238: +## Known stack suffix: +## exp EOF +## LR(1) items: +program -> exp EOF . [ # ] +## Transitions: +## Reductions: +-- On # +-- reduce production program -> exp EOF + diff --git a/src/haz3lmenhir/Parser.conflicts b/src/haz3lmenhir/Parser.conflicts new file mode 100644 index 0000000000..17bed598d3 --- /dev/null +++ b/src/haz3lmenhir/Parser.conflicts @@ -0,0 +1,33 @@ + +** Conflict (reduce/reduce) in state 156. +** Tokens involved: COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +** The following explanations concentrate on token CLOSE_SQUARE_BRACKET. +** This state is reached from program after reading: + +exp LESS_THAN OPEN_SQUARE_BRACKET QUESTION STRING + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +(?) + +** In state 156, looking ahead at CLOSE_SQUARE_BRACKET, reducing production +** exp -> QUESTION STRING +** is permitted because of the following sub-derivation: + +binExp +exp LESS_THAN exp + OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET // lookahead token appears + separated_nonempty_list(COMMA,exp) // lookahead token is inherited + exp // lookahead token is inherited + QUESTION STRING . + +** In state 156, looking ahead at CLOSE_SQUARE_BRACKET, reducing production +** typ -> QUESTION STRING +** is permitted because of the following sub-derivation: + +exp LESS_THAN typ EQUAL_ARROW typ GREATER_THAN + OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET // lookahead token appears + QUESTION STRING . diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index dddd12e4a2..44f7d81b88 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -3,6 +3,12 @@ open AST %} + + +%token T_TYP +%token P_PAT +%token TP_TPAT +%token E_EXP %token TILDE %token NAMED_FUN %token UNDEF @@ -105,6 +111,7 @@ open AST %left PLUS_FLOAT MINUS_FLOAT TIMES_FLOAT POWER_FLOAT DIVIDE_FLOAT DOUBLE_EQUAL_FLOAT NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT + (* Other *) %left CONS %left OPEN_PAREN @@ -135,7 +142,7 @@ program: | DIVIDE { IntOp(Divide) } | DOUBLE_EQUAL { IntOp(Equals) } | NOT_EQUAL { IntOp(NotEquals) } - (* | LESS_THAN { IntOp(LessThan) } *) + | LESS_THAN { IntOp(LessThan) } | LESS_THAN_EQUAL { IntOp(LessThanOrEqual) } | GREATER_THAN { IntOp(GreaterThan) } | GREATER_THAN_EQUAL { IntOp(GreaterThanOrEqual) } @@ -167,7 +174,7 @@ binExp: | e1 = exp; b = binOp; e2 = exp { BinExp (e1, b, e2) } typ: - | QUESTION; s = STRING { InvalidTyp(s) } + | QUESTION; T_TYP; s = STRING { InvalidTyp(s) } | INT_TYPE { IntType } | FLOAT_TYPE { FloatType } | BOOL_TYPE { BoolType } @@ -183,7 +190,7 @@ pat: | p1 = pat; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { CastPat(p1, t1, t2) } | OPEN_PAREN; p = pat; CLOSE_PAREN { p } | OPEN_PAREN; p = pat; COMMA; pats = separated_list(COMMA, pat); CLOSE_PAREN { TuplePat(p :: pats) } - | QUESTION; s = STRING { InvalidPat(s) } + | QUESTION; P_PAT; s = STRING { InvalidPat(s) } | WILD { WildPat } | QUESTION { EmptyHolePat } | OPEN_SQUARE_BRACKET; l = separated_list(COMMA, pat); CLOSE_SQUARE_BRACKET; { ListPat(l) } @@ -221,7 +228,7 @@ filterAction: | EVAL { Eval } tpat: - | QUESTION; s = STRING {InvalidTPat(s)} + | QUESTION; TP_TPAT; s = STRING {InvalidTPat(s)} | QUESTION {EmptyHoleTPat} | v = IDENT {VarTPat v} @@ -259,7 +266,7 @@ exp: | e1 = exp; AT_SYMBOL; e2 = exp { ListConcat(e1, e2) } | e1 = exp; CONS; e2 = exp { Cons(e1, e2) } | e1 = exp; SEMI_COLON; e2 = exp { Seq(e1, e2) } - | QUESTION; s = STRING; { InvalidExp(s) } + | QUESTION; E_EXP; s = STRING; { InvalidExp(s) } | WILD {Deferral} | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 3c15680174..f6ebf55a83 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -673,7 +673,7 @@ undef alco_check_menhir("List exp (menhir)", list_exp_str, list_exp_uexp); let invalid_str = " -?\"x\" +? e \"x\" "; let invalid_uexp: Exp.t = Invalid("x") |> Exp.fresh; let invalid_menhir = () => From ac4e9f9267679973f10bf14bdc3b639bee2ed499 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 4 Nov 2024 10:43:07 -0500 Subject: [PATCH 077/281] Fix variant constructor type in parser --- src/haz3lmenhir/Parser.mly | 3 ++- test/Test_Menhir.re | 5 +++++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 44f7d81b88..280a79d1b9 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -244,7 +244,8 @@ exp: | f = FLOAT { Float f } | v = IDENT { Var v } | c = CONSTRUCTOR_IDENT { Constructor(c, UnknownType(Internal))} - | c = CONSTRUCTOR_IDENT; TILDE; t = typ; { Cast(Constructor(c, UnknownType(Internal)), UnknownType(Internal), t) } + | c = CONSTRUCTOR_IDENT; TILDE; t = typ; { Constructor(c, t) } + | c = CONSTRUCTOR_IDENT; COLON; t = typ; { Cast(Constructor(c, UnknownType(Internal)), UnknownType(Internal), t) } | s = STRING { String s} | OPEN_PAREN; e = exp; CLOSE_PAREN { e } | OPEN_PAREN; e = exp; COMMA; l = separated_list(COMMA, exp); CLOSE_PAREN { TupleExp(e :: l) } diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 785a206e0c..c9e501d77a 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -266,6 +266,11 @@ let tests = [ Int |> Typ.fresh, ) |> Exp.fresh, + "A : Int", + ), + menhir_only_test( + "Constructor of specific sum type", + Constructor("A", Int |> Typ.fresh) |> Exp.fresh, "A ~ Int", ), parser_test( From c5861cdd0c510e6f8ef0705cce5e218b90ba7660 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 4 Nov 2024 10:56:42 -0500 Subject: [PATCH 078/281] Add commented out test for constructor with a type variable --- test/Test_Menhir.re | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index c9e501d77a..7c9fbf4089 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -273,6 +273,11 @@ let tests = [ Constructor("A", Int |> Typ.fresh) |> Exp.fresh, "A ~ Int", ), + // menhir_only_test( + // "Constructor with Type Variable", + // Constructor("A", Var("T") |> Typ.fresh) |> Exp.fresh, + // "A ~ T", + // ), parser_test( "Type Alias", TyAlias(Var("x") |> TPat.fresh, Int |> Typ.fresh, Int(1) |> Exp.fresh) From 1aec2b9075548359d9421b143245554fb6fd1090 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 4 Nov 2024 12:04:47 -0500 Subject: [PATCH 079/281] Add some commented out tests for type variables --- test/Test_Menhir.re | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 7c9fbf4089..438f44a1ef 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -273,11 +273,27 @@ let tests = [ Constructor("A", Int |> Typ.fresh) |> Exp.fresh, "A ~ Int", ), + // TODO Fix for the tests below // menhir_only_test( // "Constructor with Type Variable", // Constructor("A", Var("T") |> Typ.fresh) |> Exp.fresh, // "A ~ T", // ), + // parser_test( + // "Type Variable", + // Let( + // Cast( + // Var("x") |> Pat.fresh, + // Var("T") |> Typ.fresh, + // Unknown(Internal) |> Typ.fresh, + // ) + // |> Pat.fresh, + // EmptyHole |> Exp.fresh, + // Var("x") |> Exp.fresh, + // ) + // |> Exp.fresh, + // "let x : T = ? in x", + // ), parser_test( "Type Alias", TyAlias(Var("x") |> TPat.fresh, Int |> Typ.fresh, Int(1) |> Exp.fresh) From a265eb883e895deb20a351926b542307e79fd095 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 4 Nov 2024 12:40:25 -0500 Subject: [PATCH 080/281] Add a commented out float operations test --- test/Test_Menhir.re | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 438f44a1ef..d269f0f3fd 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -356,7 +356,37 @@ let tests = [ // Int(8) |> Exp.fresh, // ) // |> Exp.fresh, - // "-1 + 2 - 3 / 4 * 5 ** 6 >= 8" // TODO Add the remaining operators. < is also currently broken + // "-1 + 2 - 3 / 4 * 5 ** 6 >= 8" // TODO Add the remaining operators and fix precedence + parser_test("Float", Float(1.) |> Exp.fresh, "1."), + // parser_test( + // "Float Ops", + // BinOp( + // Float(LessThan), + // BinOp( + // Float(Plus), + // Float(2.) |> Exp.fresh, + // BinOp( + // Float(Divide), + // Float(3.) |> Exp.fresh, + // BinOp( + // Float(Times), + // Float(4.) |> Exp.fresh, + // BinOp( + // Float(Power), + // Float(5.) |> Exp.fresh, + // Float(6.) |> Exp.fresh, + // ) + // |> Exp.fresh, + // ) + // |> Exp.fresh, + // ) + // |> Exp.fresh, + // ) + // |> Exp.fresh, + // Float(8.) |> Exp.fresh, + // ) + // |> Exp.fresh, + // "2. +. 3. /. 4. *. 5. **. 6. <. 8." // TODO Add the remaining operators. -. is also currently broken // ), parser_test( "Let binding with type ascription", From ff2aa0f51dfaa585d8d491aabf5a33d79100b7e8 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 4 Nov 2024 12:53:17 -0500 Subject: [PATCH 081/281] Mark failing tests as skipped --- test/Test_Menhir.re | 221 ++++++++++++++++++++++++-------------------- 1 file changed, 120 insertions(+), 101 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index d269f0f3fd..594b136444 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -31,6 +31,12 @@ let menhir_matches = (name: string, exp: Term.Exp.t, actual: string) => let menhir_only_test = (name: string, exp: Term.Exp.t, actual: string) => test_case(name, `Quick, () => {menhir_matches(name, exp, actual)}); +// TODO Remove these before merge. Using it to mark skipped tests until we fix them. +let skip_parser_test = (name: string, _exp: Term.Exp.t, _actual: string) => + test_case(name, `Quick, () => {Alcotest.skip()}); +let skip_menhir_only_test = (name: string, _exp: Term.Exp.t, _actual: string) => + test_case(name, `Quick, () => {Alcotest.skip()}); + // TODO Assert against result instead of exception for parse failure for better error messages let parser_test = (name: string, exp: Term.Exp.t, actual: string) => test_case( @@ -274,26 +280,26 @@ let tests = [ "A ~ Int", ), // TODO Fix for the tests below - // menhir_only_test( - // "Constructor with Type Variable", - // Constructor("A", Var("T") |> Typ.fresh) |> Exp.fresh, - // "A ~ T", - // ), - // parser_test( - // "Type Variable", - // Let( - // Cast( - // Var("x") |> Pat.fresh, - // Var("T") |> Typ.fresh, - // Unknown(Internal) |> Typ.fresh, - // ) - // |> Pat.fresh, - // EmptyHole |> Exp.fresh, - // Var("x") |> Exp.fresh, - // ) - // |> Exp.fresh, - // "let x : T = ? in x", - // ), + skip_menhir_only_test( + "Constructor with Type Variable", + Constructor("A", Var("T") |> Typ.fresh) |> Exp.fresh, + "A ~ T", + ), + skip_parser_test( + "Type Variable", + Let( + Cast( + Var("x") |> Pat.fresh, + Var("T") |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Pat.fresh, + EmptyHole |> Exp.fresh, + Var("x") |> Exp.fresh, + ) + |> Exp.fresh, + "let x : T = ? in x", + ), parser_test( "Type Alias", TyAlias(Var("x") |> TPat.fresh, Int |> Typ.fresh, Int(1) |> Exp.fresh) @@ -327,67 +333,68 @@ let tests = [ |> Exp.fresh, "[1, 2] @ [3, 4]", ), - // parser_test( - // "Integer Ops", - // BinOp( - // Int(GreaterThanOrEqual), - // BinOp( - // Int(Minus), - // BinOp( - // Int(Plus), - // UnOp(Int(Minus), Int(1) |> Exp.fresh) |> Exp.fresh, - // Int(2) |> Exp.fresh, - // ) - // |> Exp.fresh, - // BinOp( - // Int(Divide), - // Int(3) |> Exp.fresh, - // BinOp( - // Int(Times), - // Int(4) |> Exp.fresh, - // BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) - // |> Exp.fresh, - // ) - // |> Exp.fresh, - // ) - // |> Exp.fresh, - // ) - // |> Exp.fresh, - // Int(8) |> Exp.fresh, - // ) - // |> Exp.fresh, - // "-1 + 2 - 3 / 4 * 5 ** 6 >= 8" // TODO Add the remaining operators and fix precedence + skip_parser_test( + "Integer Ops", + BinOp( + Int(GreaterThanOrEqual), + BinOp( + Int(Minus), + BinOp( + Int(Plus), + UnOp(Int(Minus), Int(1) |> Exp.fresh) |> Exp.fresh, + Int(2) |> Exp.fresh, + ) + |> Exp.fresh, + BinOp( + Int(Divide), + Int(3) |> Exp.fresh, + BinOp( + Int(Times), + Int(4) |> Exp.fresh, + BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) + |> Exp.fresh, + ) + |> Exp.fresh, + ) + |> Exp.fresh, + ) + |> Exp.fresh, + Int(8) |> Exp.fresh, + ) + |> Exp.fresh, + "-1 + 2 - 3 / 4 * 5 ** 6 >= 8", + ), // TODO Add the remaining operators and fix precedence parser_test("Float", Float(1.) |> Exp.fresh, "1."), - // parser_test( - // "Float Ops", - // BinOp( - // Float(LessThan), - // BinOp( - // Float(Plus), - // Float(2.) |> Exp.fresh, - // BinOp( - // Float(Divide), - // Float(3.) |> Exp.fresh, - // BinOp( - // Float(Times), - // Float(4.) |> Exp.fresh, - // BinOp( - // Float(Power), - // Float(5.) |> Exp.fresh, - // Float(6.) |> Exp.fresh, - // ) - // |> Exp.fresh, - // ) - // |> Exp.fresh, - // ) - // |> Exp.fresh, - // ) - // |> Exp.fresh, - // Float(8.) |> Exp.fresh, - // ) - // |> Exp.fresh, - // "2. +. 3. /. 4. *. 5. **. 6. <. 8." // TODO Add the remaining operators. -. is also currently broken - // ), + skip_parser_test( + "Float Ops", + BinOp( + Float(LessThan), + BinOp( + Float(Plus), + Float(2.) |> Exp.fresh, + BinOp( + Float(Divide), + Float(3.) |> Exp.fresh, + BinOp( + Float(Times), + Float(4.) |> Exp.fresh, + BinOp( + Float(Power), + Float(5.) |> Exp.fresh, + Float(6.) |> Exp.fresh, + ) + |> Exp.fresh, + ) + |> Exp.fresh, + ) + |> Exp.fresh, + ) + |> Exp.fresh, + Float(8.) |> Exp.fresh, + ) + |> Exp.fresh, + "2. +. 3. /. 4. *. 5. **. 6. <. 8." // TODO Add the remaining operators. -. is also currently broken + ), parser_test( "Let binding with type ascription", Let( @@ -415,25 +422,37 @@ let tests = [ |> Exp.fresh, "named_fun f x -> x + 5", ), - // { - // let strip_comments = str => { - // let re = Str.regexp("#[^#]*#"); - // Str.global_replace(re, "", str); - // }; - // let replace_holes = str => { - // let re = Str.regexp("= in"); - // Str.global_replace(re, "= ? in", str); - // }; - // - // let basic_reference = - // Haz3lweb.Init.startup.documentation - // |> (((_, slides, _)) => slides) - // |> List.assoc("Basic Reference") - // |> (slide => strip_comments(slide.backup_text)) - // |> replace_holes; - // - // print_endline(basic_reference); - // - // menhir_maketerm_equivalent_test("Basic Reference", basic_reference); - // }, + { + let strip_comments = str => { + let re = Str.regexp("#[^#]*#"); + Str.global_replace(re, "", str); + }; + let replace_holes = str => { + let re = Str.regexp("= in"); + Str.global_replace(re, "= ? in", str); + }; + + let basic_reference = + Haz3lweb.Init.startup.documentation + |> (((_, slides, _)) => slides) + |> List.assoc("Basic Reference") + |> (slide => strip_comments(slide.backup_text)) + |> replace_holes; + + print_endline(basic_reference); + test_case( + "Basic Reference", + `Quick, + () => { + let _ = Alcotest.skip(); + alco_check( + "Does not match MakeTerm", + make_term_parse(basic_reference), + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(basic_reference), + ), + ); + }, + ); + }, ]; From d444d6e59c944f60a6ffba041b6af988885aeec7 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 4 Nov 2024 12:59:16 -0500 Subject: [PATCH 082/281] Stop printing --- test/Test_Menhir.re | 1 - 1 file changed, 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 594b136444..9fcd8746b5 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -439,7 +439,6 @@ let tests = [ |> (slide => strip_comments(slide.backup_text)) |> replace_holes; - print_endline(basic_reference); test_case( "Basic Reference", `Quick, From ad1ffec7a9d14ec3aa2406cf6d7de3bd82f80359 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Thu, 7 Nov 2024 13:54:57 -0500 Subject: [PATCH 083/281] Added type variables to the menhir parser --- src/haz3lmenhir/AST.re | 1 + src/haz3lmenhir/Conversion.re | 1 + src/haz3lmenhir/Parser.automaton | 7002 ------------------------------ src/haz3lmenhir/Parser.conflicts | 33 - src/haz3lmenhir/Parser.mly | 1 + test/Test_Menhir.re | 4 +- 6 files changed, 5 insertions(+), 7037 deletions(-) delete mode 100644 src/haz3lmenhir/Parser.automaton delete mode 100644 src/haz3lmenhir/Parser.conflicts diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index c743afa84b..54db1bddc8 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -79,6 +79,7 @@ type typ = | TupleType(list(typ)) | ArrayType(typ) | ArrowType(typ, typ) + | Var(string) | InvalidTyp(string); [@deriving (show({with_path: false}), sexp)] diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 3e5e9faba2..fd5e16192f 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -225,6 +225,7 @@ and Typ: { switch (p) { | Internal => Unknown(Internal) } + | Var(s) => Var(s) | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) | ArrayType(t) => List(of_menhir_ast(t)) | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) diff --git a/src/haz3lmenhir/Parser.automaton b/src/haz3lmenhir/Parser.automaton deleted file mode 100644 index f3c54a01c2..0000000000 --- a/src/haz3lmenhir/Parser.automaton +++ /dev/null @@ -1,7002 +0,0 @@ -State 0: -## Known stack suffix: -## -## LR(1) items: -program' -> . program [ # ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On program shift to state 236 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 237 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 1: -## Known stack suffix: -## WILD -## LR(1) items: -exp -> WILD . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> WILD - -State 2: -## Known stack suffix: -## UNDEF -## LR(1) items: -exp -> UNDEF . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> UNDEF - -State 3: -## Known stack suffix: -## TYP_FUN -## LR(1) items: -exp -> TYP_FUN . tpat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On QUESTION shift to state 4 --- On IDENT shift to state 6 --- On tpat shift to state 7 -## Reductions: - -State 4: -## Known stack suffix: -## QUESTION -## LR(1) items: -tpat -> QUESTION . STRING [ SINGLE_EQUAL DASH_ARROW ] -tpat -> QUESTION . [ SINGLE_EQUAL DASH_ARROW ] -## Transitions: --- On STRING shift to state 5 -## Reductions: --- On SINGLE_EQUAL DASH_ARROW --- reduce production tpat -> QUESTION - -State 5: -## Known stack suffix: -## QUESTION STRING -## LR(1) items: -tpat -> QUESTION STRING . [ SINGLE_EQUAL DASH_ARROW ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL DASH_ARROW --- reduce production tpat -> QUESTION STRING - -State 6: -## Known stack suffix: -## IDENT -## LR(1) items: -tpat -> IDENT . [ SINGLE_EQUAL DASH_ARROW ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL DASH_ARROW --- reduce production tpat -> IDENT - -State 7: -## Known stack suffix: -## TYP_FUN tpat -## LR(1) items: -exp -> TYP_FUN tpat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On DASH_ARROW shift to state 8 -## Reductions: - -State 8: -## Known stack suffix: -## TYP_FUN tpat DASH_ARROW -## LR(1) items: -exp -> TYP_FUN tpat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 235 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 9: -## Known stack suffix: -## TYP -## LR(1) items: -exp -> TYP . tpat SINGLE_EQUAL typ IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On QUESTION shift to state 4 --- On IDENT shift to state 6 --- On tpat shift to state 10 -## Reductions: - -State 10: -## Known stack suffix: -## TYP tpat -## LR(1) items: -exp -> TYP tpat . SINGLE_EQUAL typ IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SINGLE_EQUAL shift to state 11 -## Reductions: - -State 11: -## Known stack suffix: -## TYP tpat SINGLE_EQUAL -## LR(1) items: -exp -> TYP tpat SINGLE_EQUAL . typ IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 33 -## Reductions: - -State 12: -## Known stack suffix: -## UNKNOWN -## LR(1) items: -typ -> UNKNOWN . INTERNAL [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On INTERNAL shift to state 13 -## Reductions: - -State 13: -## Known stack suffix: -## UNKNOWN INTERNAL -## LR(1) items: -typ -> UNKNOWN INTERNAL . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production typ -> UNKNOWN INTERNAL - -State 14: -## Known stack suffix: -## UNIT -## LR(1) items: -typ -> UNIT . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production typ -> UNIT - -State 15: -## Known stack suffix: -## STRING_TYPE -## LR(1) items: -typ -> STRING_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production typ -> STRING_TYPE - -State 16: -## Known stack suffix: -## QUESTION -## LR(1) items: -typ -> QUESTION . STRING [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING shift to state 17 -## Reductions: - -State 17: -## Known stack suffix: -## QUESTION STRING -## LR(1) items: -typ -> QUESTION STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production typ -> QUESTION STRING - -State 18: -## Known stack suffix: -## OPEN_SQUARE_BRACKET -## LR(1) items: -typ -> OPEN_SQUARE_BRACKET . typ CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 31 -## Reductions: - -State 19: -## Known stack suffix: -## OPEN_PAREN -## LR(1) items: -typ -> OPEN_PAREN . loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 23 --- On separated_nonempty_list(COMMA,typ) shift to state 28 --- On loption(separated_nonempty_list(COMMA,typ)) shift to state 29 -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,typ)) -> - -State 20: -## Known stack suffix: -## INT_TYPE -## LR(1) items: -typ -> INT_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production typ -> INT_TYPE - -State 21: -## Known stack suffix: -## FLOAT_TYPE -## LR(1) items: -typ -> FLOAT_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production typ -> FLOAT_TYPE - -State 22: -## Known stack suffix: -## BOOL_TYPE -## LR(1) items: -typ -> BOOL_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production typ -> BOOL_TYPE - -State 23: -## Known stack suffix: -## typ -## LR(1) items: -separated_nonempty_list(COMMA,typ) -> typ . [ CLOSE_PAREN ] -separated_nonempty_list(COMMA,typ) -> typ . COMMA separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ DASH_ARROW COMMA CLOSE_PAREN ] -## Transitions: --- On DASH_ARROW shift to state 24 --- On COMMA shift to state 26 -## Reductions: --- On CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,typ) -> typ - -State 24: -## Known stack suffix: -## typ DASH_ARROW -## LR(1) items: -typ -> typ DASH_ARROW . typ [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 25 -## Reductions: - -State 25: -## Known stack suffix: -## typ DASH_ARROW typ -## LR(1) items: -typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ DASH_ARROW typ . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production typ -> typ DASH_ARROW typ - -State 26: -## Known stack suffix: -## typ COMMA -## LR(1) items: -separated_nonempty_list(COMMA,typ) -> typ COMMA . separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 23 --- On separated_nonempty_list(COMMA,typ) shift to state 27 -## Reductions: - -State 27: -## Known stack suffix: -## typ COMMA separated_nonempty_list(COMMA,typ) -## LR(1) items: -separated_nonempty_list(COMMA,typ) -> typ COMMA separated_nonempty_list(COMMA,typ) . [ CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,typ) -> typ COMMA separated_nonempty_list(COMMA,typ) - -State 28: -## Known stack suffix: -## separated_nonempty_list(COMMA,typ) -## LR(1) items: -loption(separated_nonempty_list(COMMA,typ)) -> separated_nonempty_list(COMMA,typ) . [ CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,typ)) -> separated_nonempty_list(COMMA,typ) - -State 29: -## Known stack suffix: -## OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) -## LR(1) items: -typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On CLOSE_PAREN shift to state 30 -## Reductions: - -State 30: -## Known stack suffix: -## OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN -## LR(1) items: -typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN - -State 31: -## Known stack suffix: -## OPEN_SQUARE_BRACKET typ -## LR(1) items: -typ -> OPEN_SQUARE_BRACKET typ . CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ DASH_ARROW CLOSE_SQUARE_BRACKET ] -## Transitions: --- On DASH_ARROW shift to state 24 --- On CLOSE_SQUARE_BRACKET shift to state 32 -## Reductions: - -State 32: -## Known stack suffix: -## OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET -## LR(1) items: -typ -> OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET . [ TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production typ -> OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET - -State 33: -## Known stack suffix: -## TYP tpat SINGLE_EQUAL typ -## LR(1) items: -exp -> TYP tpat SINGLE_EQUAL typ . IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ IN DASH_ARROW ] -## Transitions: --- On IN shift to state 34 --- On DASH_ARROW shift to state 24 -## Reductions: - -State 34: -## Known stack suffix: -## TYP tpat SINGLE_EQUAL typ IN -## LR(1) items: -exp -> TYP tpat SINGLE_EQUAL typ IN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 234 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 35: -## Known stack suffix: -## TRUE -## LR(1) items: -exp -> TRUE . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> TRUE - -State 36: -## Known stack suffix: -## TEST -## LR(1) items: -exp -> TEST . exp END [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 232 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 37: -## Known stack suffix: -## STRING -## LR(1) items: -exp -> STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> STRING - -State 38: -## Known stack suffix: -## QUESTION -## LR(1) items: -exp -> QUESTION . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> QUESTION . STRING [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING shift to state 39 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> QUESTION - -State 39: -## Known stack suffix: -## QUESTION STRING -## LR(1) items: -exp -> QUESTION STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> QUESTION STRING - -State 40: -## Known stack suffix: -## PAUSE -## LR(1) items: -filterAction -> PAUSE . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] -## Transitions: -## Reductions: --- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN --- reduce production filterAction -> PAUSE - -State 41: -## Known stack suffix: -## OPEN_SQUARE_BRACKET -## LR(1) items: -exp -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On separated_nonempty_list(COMMA,exp) shift to state 187 --- On loption(separated_nonempty_list(COMMA,exp)) shift to state 194 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 190 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: --- On CLOSE_SQUARE_BRACKET --- reduce production loption(separated_nonempty_list(COMMA,exp)) -> - -State 42: -## Known stack suffix: -## OPEN_PAREN -## LR(1) items: -exp -> OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> OPEN_PAREN . exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 159 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 43: -## Known stack suffix: -## NAMED_FUN -## LR(1) items: -funExp -> NAMED_FUN . IDENT pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On IDENT shift to state 44 -## Reductions: - -State 44: -## Known stack suffix: -## NAMED_FUN IDENT -## LR(1) items: -funExp -> NAMED_FUN IDENT . pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 45 --- On TRUE shift to state 46 --- On STRING shift to state 47 --- On QUESTION shift to state 48 --- On OPEN_SQUARE_BRACKET shift to state 50 --- On OPEN_PAREN shift to state 51 --- On INT shift to state 52 --- On IDENT shift to state 53 --- On FLOAT shift to state 54 --- On FALSE shift to state 55 --- On CONSTRUCTOR_IDENT shift to state 56 --- On pat shift to state 82 -## Reductions: - -State 45: -## Known stack suffix: -## WILD -## LR(1) items: -pat -> WILD . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> WILD - -State 46: -## Known stack suffix: -## TRUE -## LR(1) items: -pat -> TRUE . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> TRUE - -State 47: -## Known stack suffix: -## STRING -## LR(1) items: -pat -> STRING . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> STRING - -State 48: -## Known stack suffix: -## QUESTION -## LR(1) items: -pat -> QUESTION . STRING [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> QUESTION . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 49 -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> QUESTION - -State 49: -## Known stack suffix: -## QUESTION STRING -## LR(1) items: -pat -> QUESTION STRING . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> QUESTION STRING - -State 50: -## Known stack suffix: -## OPEN_SQUARE_BRACKET -## LR(1) items: -pat -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 45 --- On TRUE shift to state 46 --- On STRING shift to state 47 --- On QUESTION shift to state 48 --- On OPEN_SQUARE_BRACKET shift to state 50 --- On OPEN_PAREN shift to state 51 --- On INT shift to state 52 --- On IDENT shift to state 53 --- On FLOAT shift to state 54 --- On FALSE shift to state 55 --- On CONSTRUCTOR_IDENT shift to state 56 --- On separated_nonempty_list(COMMA,pat) shift to state 73 --- On pat shift to state 74 --- On loption(separated_nonempty_list(COMMA,pat)) shift to state 80 -## Reductions: --- On CLOSE_SQUARE_BRACKET --- reduce production loption(separated_nonempty_list(COMMA,pat)) -> - -State 51: -## Known stack suffix: -## OPEN_PAREN -## LR(1) items: -pat -> OPEN_PAREN . pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> OPEN_PAREN . pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 45 --- On TRUE shift to state 46 --- On STRING shift to state 47 --- On QUESTION shift to state 48 --- On OPEN_SQUARE_BRACKET shift to state 50 --- On OPEN_PAREN shift to state 51 --- On INT shift to state 52 --- On IDENT shift to state 53 --- On FLOAT shift to state 54 --- On FALSE shift to state 55 --- On CONSTRUCTOR_IDENT shift to state 56 --- On pat shift to state 59 -## Reductions: - -State 52: -## Known stack suffix: -## INT -## LR(1) items: -pat -> INT . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> INT - -State 53: -## Known stack suffix: -## IDENT -## LR(1) items: -pat -> IDENT . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> IDENT - -State 54: -## Known stack suffix: -## FLOAT -## LR(1) items: -pat -> FLOAT . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> FLOAT - -State 55: -## Known stack suffix: -## FALSE -## LR(1) items: -pat -> FALSE . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> FALSE - -State 56: -## Known stack suffix: -## CONSTRUCTOR_IDENT -## LR(1) items: -pat -> CONSTRUCTOR_IDENT . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> CONSTRUCTOR_IDENT . TILDE typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On TILDE shift to state 57 -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> CONSTRUCTOR_IDENT - -State 57: -## Known stack suffix: -## CONSTRUCTOR_IDENT TILDE -## LR(1) items: -pat -> CONSTRUCTOR_IDENT TILDE . typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 58 -## Reductions: - -State 58: -## Known stack suffix: -## CONSTRUCTOR_IDENT TILDE typ -## LR(1) items: -pat -> CONSTRUCTOR_IDENT TILDE typ . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> CONSTRUCTOR_IDENT TILDE typ - -State 59: -## Known stack suffix: -## OPEN_PAREN pat -## LR(1) items: -pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_PAREN ] -pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_PAREN ] -pat -> OPEN_PAREN pat . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> OPEN_PAREN pat . COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_PAREN ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_PAREN ] -## Transitions: --- On OPEN_PAREN shift to state 60 --- On LESS_THAN shift to state 62 --- On CONS shift to state 67 --- On COMMA shift to state 72 --- On COLON shift to state 69 --- On CLOSE_PAREN shift to state 79 -## Reductions: - -State 60: -## Known stack suffix: -## pat OPEN_PAREN -## LR(1) items: -pat -> pat OPEN_PAREN . pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 45 --- On TRUE shift to state 46 --- On STRING shift to state 47 --- On QUESTION shift to state 48 --- On OPEN_SQUARE_BRACKET shift to state 50 --- On OPEN_PAREN shift to state 51 --- On INT shift to state 52 --- On IDENT shift to state 53 --- On FLOAT shift to state 54 --- On FALSE shift to state 55 --- On CONSTRUCTOR_IDENT shift to state 56 --- On pat shift to state 61 -## Reductions: - -State 61: -## Known stack suffix: -## pat OPEN_PAREN pat -## LR(1) items: -pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN CONS COLON CLOSE_PAREN ] -pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN CONS COLON CLOSE_PAREN ] -pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN CONS COLON CLOSE_PAREN ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN CONS COLON CLOSE_PAREN ] -pat -> pat OPEN_PAREN pat . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On OPEN_PAREN shift to state 60 --- On LESS_THAN shift to state 62 --- On CONS shift to state 67 --- On COLON shift to state 69 --- On CLOSE_PAREN shift to state 71 -## Reductions: - -State 62: -## Known stack suffix: -## pat LESS_THAN -## LR(1) items: -pat -> pat LESS_THAN . typ EQUAL_ARROW typ GREATER_THAN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 63 -## Reductions: - -State 63: -## Known stack suffix: -## pat LESS_THAN typ -## LR(1) items: -pat -> pat LESS_THAN typ . EQUAL_ARROW typ GREATER_THAN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] -## Transitions: --- On EQUAL_ARROW shift to state 64 --- On DASH_ARROW shift to state 24 -## Reductions: - -State 64: -## Known stack suffix: -## pat LESS_THAN typ EQUAL_ARROW -## LR(1) items: -pat -> pat LESS_THAN typ EQUAL_ARROW . typ GREATER_THAN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 65 -## Reductions: - -State 65: -## Known stack suffix: -## pat LESS_THAN typ EQUAL_ARROW typ -## LR(1) items: -pat -> pat LESS_THAN typ EQUAL_ARROW typ . GREATER_THAN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ GREATER_THAN DASH_ARROW ] -## Transitions: --- On GREATER_THAN shift to state 66 --- On DASH_ARROW shift to state 24 -## Reductions: - -State 66: -## Known stack suffix: -## pat LESS_THAN typ EQUAL_ARROW typ GREATER_THAN -## LR(1) items: -pat -> pat LESS_THAN typ EQUAL_ARROW typ GREATER_THAN . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> pat LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -State 67: -## Known stack suffix: -## pat CONS -## LR(1) items: -pat -> pat CONS . pat [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 45 --- On TRUE shift to state 46 --- On STRING shift to state 47 --- On QUESTION shift to state 48 --- On OPEN_SQUARE_BRACKET shift to state 50 --- On OPEN_PAREN shift to state 51 --- On INT shift to state 52 --- On IDENT shift to state 53 --- On FLOAT shift to state 54 --- On FALSE shift to state 55 --- On CONSTRUCTOR_IDENT shift to state 56 --- On pat shift to state 68 -## Reductions: - -State 68: -## Known stack suffix: -## pat CONS pat -## LR(1) items: -pat -> pat . COLON typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . CONS pat [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat CONS pat . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On OPEN_PAREN shift to state 60 --- On COLON shift to state 69 -## Reductions: --- On SINGLE_EQUAL LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> pat CONS pat - -State 69: -## Known stack suffix: -## pat COLON -## LR(1) items: -pat -> pat COLON . typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 70 -## Reductions: - -State 70: -## Known stack suffix: -## pat COLON typ -## LR(1) items: -pat -> pat COLON typ . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> pat COLON typ - -State 71: -## Known stack suffix: -## pat OPEN_PAREN pat CLOSE_PAREN -## LR(1) items: -pat -> pat OPEN_PAREN pat CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> pat OPEN_PAREN pat CLOSE_PAREN - -State 72: -## Known stack suffix: -## OPEN_PAREN pat COMMA -## LR(1) items: -pat -> OPEN_PAREN pat COMMA . loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 45 --- On TRUE shift to state 46 --- On STRING shift to state 47 --- On QUESTION shift to state 48 --- On OPEN_SQUARE_BRACKET shift to state 50 --- On OPEN_PAREN shift to state 51 --- On INT shift to state 52 --- On IDENT shift to state 53 --- On FLOAT shift to state 54 --- On FALSE shift to state 55 --- On CONSTRUCTOR_IDENT shift to state 56 --- On separated_nonempty_list(COMMA,pat) shift to state 73 --- On pat shift to state 74 --- On loption(separated_nonempty_list(COMMA,pat)) shift to state 77 -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,pat)) -> - -State 73: -## Known stack suffix: -## separated_nonempty_list(COMMA,pat) -## LR(1) items: -loption(separated_nonempty_list(COMMA,pat)) -> separated_nonempty_list(COMMA,pat) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,pat)) -> separated_nonempty_list(COMMA,pat) - -State 74: -## Known stack suffix: -## pat -## LR(1) items: -pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -separated_nonempty_list(COMMA,pat) -> pat . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -separated_nonempty_list(COMMA,pat) -> pat . COMMA separated_nonempty_list(COMMA,pat) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On OPEN_PAREN shift to state 60 --- On LESS_THAN shift to state 62 --- On CONS shift to state 67 --- On COMMA shift to state 75 --- On COLON shift to state 69 -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,pat) -> pat - -State 75: -## Known stack suffix: -## pat COMMA -## LR(1) items: -separated_nonempty_list(COMMA,pat) -> pat COMMA . separated_nonempty_list(COMMA,pat) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 45 --- On TRUE shift to state 46 --- On STRING shift to state 47 --- On QUESTION shift to state 48 --- On OPEN_SQUARE_BRACKET shift to state 50 --- On OPEN_PAREN shift to state 51 --- On INT shift to state 52 --- On IDENT shift to state 53 --- On FLOAT shift to state 54 --- On FALSE shift to state 55 --- On CONSTRUCTOR_IDENT shift to state 56 --- On separated_nonempty_list(COMMA,pat) shift to state 76 --- On pat shift to state 74 -## Reductions: - -State 76: -## Known stack suffix: -## pat COMMA separated_nonempty_list(COMMA,pat) -## LR(1) items: -separated_nonempty_list(COMMA,pat) -> pat COMMA separated_nonempty_list(COMMA,pat) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,pat) -> pat COMMA separated_nonempty_list(COMMA,pat) - -State 77: -## Known stack suffix: -## OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) -## LR(1) items: -pat -> OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On CLOSE_PAREN shift to state 78 -## Reductions: - -State 78: -## Known stack suffix: -## OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN -## LR(1) items: -pat -> OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN - -State 79: -## Known stack suffix: -## OPEN_PAREN pat CLOSE_PAREN -## LR(1) items: -pat -> OPEN_PAREN pat CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> OPEN_PAREN pat CLOSE_PAREN - -State 80: -## Known stack suffix: -## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) -## LR(1) items: -pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) . CLOSE_SQUARE_BRACKET [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On CLOSE_SQUARE_BRACKET shift to state 81 -## Reductions: - -State 81: -## Known stack suffix: -## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET -## LR(1) items: -pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET . [ SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN LESS_THAN EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET - -State 82: -## Known stack suffix: -## NAMED_FUN IDENT pat -## LR(1) items: -funExp -> NAMED_FUN IDENT pat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] -pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] -pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] -## Transitions: --- On OPEN_PAREN shift to state 60 --- On LESS_THAN shift to state 62 --- On DASH_ARROW shift to state 83 --- On CONS shift to state 67 --- On COLON shift to state 69 -## Reductions: - -State 83: -## Known stack suffix: -## NAMED_FUN IDENT pat DASH_ARROW -## LR(1) items: -funExp -> NAMED_FUN IDENT pat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 231 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 84: -## Known stack suffix: -## MINUS -## LR(1) items: -unExp -> MINUS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 230 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 85: -## Known stack suffix: -## L_NOT -## LR(1) items: -unExp -> L_NOT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 229 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 86: -## Known stack suffix: -## LET -## LR(1) items: -exp -> LET . pat SINGLE_EQUAL exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 45 --- On TRUE shift to state 46 --- On STRING shift to state 47 --- On QUESTION shift to state 48 --- On OPEN_SQUARE_BRACKET shift to state 50 --- On OPEN_PAREN shift to state 51 --- On INT shift to state 52 --- On IDENT shift to state 53 --- On FLOAT shift to state 54 --- On FALSE shift to state 55 --- On CONSTRUCTOR_IDENT shift to state 56 --- On pat shift to state 87 -## Reductions: - -State 87: -## Known stack suffix: -## LET pat -## LR(1) items: -exp -> LET pat . SINGLE_EQUAL exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -pat -> pat . COLON typ [ SINGLE_EQUAL OPEN_PAREN LESS_THAN CONS COLON ] -pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN CONS COLON ] -pat -> pat . CONS pat [ SINGLE_EQUAL OPEN_PAREN LESS_THAN CONS COLON ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN LESS_THAN CONS COLON ] -## Transitions: --- On SINGLE_EQUAL shift to state 88 --- On OPEN_PAREN shift to state 60 --- On LESS_THAN shift to state 62 --- On CONS shift to state 67 --- On COLON shift to state 69 -## Reductions: - -State 88: -## Known stack suffix: -## LET pat SINGLE_EQUAL -## LR(1) items: -exp -> LET pat SINGLE_EQUAL . exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 226 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 89: -## Known stack suffix: -## LESS_THAN -## LR(1) items: -exp -> LESS_THAN . LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On LESS_THAN shift to state 90 -## Reductions: - -State 90: -## Known stack suffix: -## LESS_THAN LESS_THAN -## LR(1) items: -exp -> LESS_THAN LESS_THAN . exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 221 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 91: -## Known stack suffix: -## INT -## LR(1) items: -exp -> INT . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> INT - -State 92: -## Known stack suffix: -## IF -## LR(1) items: -exp -> IF . exp THEN exp ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 216 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 93: -## Known stack suffix: -## IDENT -## LR(1) items: -exp -> IDENT . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> IDENT - -State 94: -## Known stack suffix: -## HIDE -## LR(1) items: -filterAction -> HIDE . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] -## Transitions: -## Reductions: --- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN --- reduce production filterAction -> HIDE - -State 95: -## Known stack suffix: -## FUN -## LR(1) items: -funExp -> FUN . pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 45 --- On TRUE shift to state 46 --- On STRING shift to state 47 --- On QUESTION shift to state 48 --- On OPEN_SQUARE_BRACKET shift to state 50 --- On OPEN_PAREN shift to state 51 --- On INT shift to state 52 --- On IDENT shift to state 53 --- On FLOAT shift to state 54 --- On FALSE shift to state 55 --- On CONSTRUCTOR_IDENT shift to state 56 --- On pat shift to state 96 -## Reductions: - -State 96: -## Known stack suffix: -## FUN pat -## LR(1) items: -funExp -> FUN pat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] -pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] -pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] -## Transitions: --- On OPEN_PAREN shift to state 60 --- On LESS_THAN shift to state 62 --- On DASH_ARROW shift to state 97 --- On CONS shift to state 67 --- On COLON shift to state 69 -## Reductions: - -State 97: -## Known stack suffix: -## FUN pat DASH_ARROW -## LR(1) items: -funExp -> FUN pat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 215 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 98: -## Known stack suffix: -## FLOAT -## LR(1) items: -exp -> FLOAT . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> FLOAT - -State 99: -## Known stack suffix: -## FIX -## LR(1) items: -exp -> FIX . pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 45 --- On TRUE shift to state 46 --- On STRING shift to state 47 --- On QUESTION shift to state 48 --- On OPEN_SQUARE_BRACKET shift to state 50 --- On OPEN_PAREN shift to state 51 --- On INT shift to state 52 --- On IDENT shift to state 53 --- On FLOAT shift to state 54 --- On FALSE shift to state 55 --- On CONSTRUCTOR_IDENT shift to state 56 --- On pat shift to state 100 -## Reductions: - -State 100: -## Known stack suffix: -## FIX pat -## LR(1) items: -exp -> FIX pat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] -pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] -pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN DASH_ARROW CONS COLON ] -## Transitions: --- On OPEN_PAREN shift to state 60 --- On LESS_THAN shift to state 62 --- On DASH_ARROW shift to state 101 --- On CONS shift to state 67 --- On COLON shift to state 69 -## Reductions: - -State 101: -## Known stack suffix: -## FIX pat DASH_ARROW -## LR(1) items: -exp -> FIX pat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 214 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 102: -## Known stack suffix: -## FALSE -## LR(1) items: -exp -> FALSE . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> FALSE - -State 103: -## Known stack suffix: -## EVAL -## LR(1) items: -filterAction -> EVAL . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] -## Transitions: -## Reductions: --- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN --- reduce production filterAction -> EVAL - -State 104: -## Known stack suffix: -## DOLLAR_SIGN -## LR(1) items: -unExp -> DOLLAR_SIGN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 213 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 105: -## Known stack suffix: -## DEBUG -## LR(1) items: -filterAction -> DEBUG . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] -## Transitions: -## Reductions: --- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN --- reduce production filterAction -> DEBUG - -State 106: -## Known stack suffix: -## CONSTRUCTOR_IDENT -## LR(1) items: -exp -> CONSTRUCTOR_IDENT . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> CONSTRUCTOR_IDENT . TILDE typ [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TILDE shift to state 107 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> CONSTRUCTOR_IDENT - -State 107: -## Known stack suffix: -## CONSTRUCTOR_IDENT TILDE -## LR(1) items: -exp -> CONSTRUCTOR_IDENT TILDE . typ [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 108 -## Reductions: - -State 108: -## Known stack suffix: -## CONSTRUCTOR_IDENT TILDE typ -## LR(1) items: -exp -> CONSTRUCTOR_IDENT TILDE typ . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On DASH_ARROW shift to state 24 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> CONSTRUCTOR_IDENT TILDE typ - -State 109: -## Known stack suffix: -## CASE -## LR(1) items: -case -> CASE . exp list(rul) END [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 204 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 110: -## Known stack suffix: -## BUILTIN -## LR(1) items: -exp -> BUILTIN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> BUILTIN - -State 111: -## Known stack suffix: -## unExp -## LR(1) items: -exp -> unExp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> unExp - -State 112: -## Known stack suffix: -## funExp -## LR(1) items: -exp -> funExp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> funExp - -State 113: -## Known stack suffix: -## filterAction -## LR(1) items: -exp -> filterAction . exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 114 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 114: -## Known stack suffix: -## filterAction exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> filterAction exp . IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On IN shift to state 202 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: - -State 115: -## Known stack suffix: -## exp TIMES_FLOAT -## LR(1) items: -binExp -> exp TIMES_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 116 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 116: -## Known stack suffix: -## exp TIMES_FLOAT exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp TIMES_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On OPEN_PAREN shift to state 131 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp TIMES_FLOAT exp - -State 117: -## Known stack suffix: -## exp SEMI_COLON -## LR(1) items: -exp -> exp SEMI_COLON . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 118 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 118: -## Known stack suffix: -## exp SEMI_COLON exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp SEMI_COLON exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On L_OR shift to state 119 --- On L_AND shift to state 123 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> exp SEMI_COLON exp - -State 119: -## Known stack suffix: -## exp L_OR -## LR(1) items: -binExp -> exp L_OR . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 120 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 120: -## Known stack suffix: -## exp L_OR exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp L_OR exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production binExp -> exp L_OR exp - -State 121: -## Known stack suffix: -## case -## LR(1) items: -exp -> case . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> case - -State 122: -## Known stack suffix: -## binExp -## LR(1) items: -exp -> binExp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> binExp - -State 123: -## Known stack suffix: -## exp L_AND -## LR(1) items: -binExp -> exp L_AND . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 124 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 124: -## Known stack suffix: -## exp L_AND exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp L_AND exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production binExp -> exp L_AND exp - -State 125: -## Known stack suffix: -## exp QUESTION -## LR(1) items: -exp -> exp QUESTION . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On LESS_THAN shift to state 126 -## Reductions: - -State 126: -## Known stack suffix: -## exp QUESTION LESS_THAN -## LR(1) items: -exp -> exp QUESTION LESS_THAN . typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 127 -## Reductions: - -State 127: -## Known stack suffix: -## exp QUESTION LESS_THAN typ -## LR(1) items: -exp -> exp QUESTION LESS_THAN typ . EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] -## Transitions: --- On EQUAL_ARROW shift to state 128 --- On DASH_ARROW shift to state 24 -## Reductions: - -State 128: -## Known stack suffix: -## exp QUESTION LESS_THAN typ EQUAL_ARROW -## LR(1) items: -exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW . typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 129 -## Reductions: - -State 129: -## Known stack suffix: -## exp QUESTION LESS_THAN typ EQUAL_ARROW typ -## LR(1) items: -exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW typ . GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ GREATER_THAN DASH_ARROW ] -## Transitions: --- On GREATER_THAN shift to state 130 --- On DASH_ARROW shift to state 24 -## Reductions: - -State 130: -## Known stack suffix: -## exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN -## LR(1) items: -exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> exp QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -State 131: -## Known stack suffix: -## exp OPEN_PAREN -## LR(1) items: -exp -> exp OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 132 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 132: -## Known stack suffix: -## exp OPEN_PAREN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp OPEN_PAREN exp . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On CLOSE_PAREN shift to state 201 --- On AT_SYMBOL shift to state 139 -## Reductions: - -State 133: -## Known stack suffix: -## exp TIMES -## LR(1) items: -binExp -> exp TIMES . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 134 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 134: -## Known stack suffix: -## exp TIMES exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp TIMES exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On PLUS_FLOAT shift to state 144 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On MINUS_FLOAT shift to state 148 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DIVIDE_FLOAT shift to state 170 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp TIMES exp - -State 135: -## Known stack suffix: -## exp POWER_FLOAT -## LR(1) items: -binExp -> exp POWER_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 136 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 136: -## Known stack suffix: -## exp POWER_FLOAT exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp POWER_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On OPEN_PAREN shift to state 131 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp POWER_FLOAT exp - -State 137: -## Known stack suffix: -## exp CONS -## LR(1) items: -exp -> exp CONS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 138 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 138: -## Known stack suffix: -## exp CONS exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp CONS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On OPEN_PAREN shift to state 131 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> exp CONS exp - -State 139: -## Known stack suffix: -## exp AT_SYMBOL -## LR(1) items: -exp -> exp AT_SYMBOL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp AT_SYMBOL . LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 140 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 143 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 140: -## Known stack suffix: -## exp AT_SYMBOL LESS_THAN -## LR(1) items: -exp -> exp AT_SYMBOL LESS_THAN . typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> LESS_THAN . LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On LESS_THAN shift to state 90 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 141 -## Reductions: - -State 141: -## Known stack suffix: -## exp AT_SYMBOL LESS_THAN typ -## LR(1) items: -exp -> exp AT_SYMBOL LESS_THAN typ . GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ GREATER_THAN DASH_ARROW ] -## Transitions: --- On GREATER_THAN shift to state 142 --- On DASH_ARROW shift to state 24 -## Reductions: - -State 142: -## Known stack suffix: -## exp AT_SYMBOL LESS_THAN typ GREATER_THAN -## LR(1) items: -exp -> exp AT_SYMBOL LESS_THAN typ GREATER_THAN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> exp AT_SYMBOL LESS_THAN typ GREATER_THAN - -State 143: -## Known stack suffix: -## exp AT_SYMBOL exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp AT_SYMBOL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On L_OR shift to state 119 --- On L_AND shift to state 123 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> exp AT_SYMBOL exp - -State 144: -## Known stack suffix: -## exp PLUS_FLOAT -## LR(1) items: -binExp -> exp PLUS_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 145 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 145: -## Known stack suffix: -## exp PLUS_FLOAT exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp PLUS_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On OPEN_PAREN shift to state 131 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp PLUS_FLOAT exp - -State 146: -## Known stack suffix: -## exp NOT_EQUAL_FLOAT -## LR(1) items: -binExp -> exp NOT_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 147 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 147: -## Known stack suffix: -## exp NOT_EQUAL_FLOAT exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp NOT_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On OPEN_PAREN shift to state 131 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp NOT_EQUAL_FLOAT exp - -State 148: -## Known stack suffix: -## exp MINUS_FLOAT -## LR(1) items: -binExp -> exp MINUS_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 149 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 149: -## Known stack suffix: -## exp MINUS_FLOAT exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp MINUS_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On OPEN_PAREN shift to state 131 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp MINUS_FLOAT exp - -State 150: -## Known stack suffix: -## exp LESS_THAN_FLOAT -## LR(1) items: -binExp -> exp LESS_THAN_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 151 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 151: -## Known stack suffix: -## exp LESS_THAN_FLOAT exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp LESS_THAN_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On OPEN_PAREN shift to state 131 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp LESS_THAN_FLOAT exp - -State 152: -## Known stack suffix: -## exp LESS_THAN_EQUAL_FLOAT -## LR(1) items: -binExp -> exp LESS_THAN_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 153 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 153: -## Known stack suffix: -## exp LESS_THAN_EQUAL_FLOAT exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp LESS_THAN_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On OPEN_PAREN shift to state 131 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp LESS_THAN_EQUAL_FLOAT exp - -State 154: -## Known stack suffix: -## exp LESS_THAN -## LR(1) items: -binExp -> exp LESS_THAN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp LESS_THAN . typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING_TYPE shift to state 15 --- On STRING shift to state 37 --- On QUESTION shift to state 155 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 157 --- On OPEN_PAREN shift to state 158 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT_TYPE shift to state 20 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT_TYPE shift to state 21 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On BOOL_TYPE shift to state 22 --- On unExp shift to state 111 --- On typ shift to state 196 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 200 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 155: -## Known stack suffix: -## QUESTION -## LR(1) items: -exp -> QUESTION . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> QUESTION . STRING [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> QUESTION . STRING [ EQUAL_ARROW DASH_ARROW COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 156 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> QUESTION - -State 156: -## Known stack suffix: -## QUESTION STRING -## LR(1) items: -exp -> QUESTION STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> QUESTION STRING . [ EQUAL_ARROW DASH_ARROW COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> QUESTION STRING --- On EQUAL_ARROW DASH_ARROW COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production typ -> QUESTION STRING -** Conflict on COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN - -State 157: -## Known stack suffix: -## OPEN_SQUARE_BRACKET -## LR(1) items: -exp -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> OPEN_SQUARE_BRACKET . typ CLOSE_SQUARE_BRACKET [ EQUAL_ARROW DASH_ARROW COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 1 --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING_TYPE shift to state 15 --- On STRING shift to state 37 --- On QUESTION shift to state 155 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 157 --- On OPEN_PAREN shift to state 158 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT_TYPE shift to state 20 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT_TYPE shift to state 21 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On BOOL_TYPE shift to state 22 --- On unExp shift to state 111 --- On typ shift to state 31 --- On separated_nonempty_list(COMMA,exp) shift to state 187 --- On loption(separated_nonempty_list(COMMA,exp)) shift to state 194 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 190 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: --- On CLOSE_SQUARE_BRACKET --- reduce production loption(separated_nonempty_list(COMMA,exp)) -> - -State 158: -## Known stack suffix: -## OPEN_PAREN -## LR(1) items: -exp -> OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> OPEN_PAREN . exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> OPEN_PAREN . loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ EQUAL_ARROW DASH_ARROW COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 1 --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING_TYPE shift to state 15 --- On STRING shift to state 37 --- On QUESTION shift to state 155 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 157 --- On OPEN_PAREN shift to state 158 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT_TYPE shift to state 20 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT_TYPE shift to state 21 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On BOOL_TYPE shift to state 22 --- On unExp shift to state 111 --- On typ shift to state 23 --- On separated_nonempty_list(COMMA,typ) shift to state 28 --- On loption(separated_nonempty_list(COMMA,typ)) shift to state 29 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 159 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,typ)) -> - -State 159: -## Known stack suffix: -## OPEN_PAREN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> OPEN_PAREN exp . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> OPEN_PAREN exp . COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On COMMA shift to state 186 --- On CLOSE_PAREN shift to state 193 --- On AT_SYMBOL shift to state 139 -## Reductions: - -State 160: -## Known stack suffix: -## exp POWER -## LR(1) items: -binExp -> exp POWER . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 161 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 161: -## Known stack suffix: -## exp POWER exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp POWER exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On PLUS_FLOAT shift to state 144 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On MINUS_FLOAT shift to state 148 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DIVIDE_FLOAT shift to state 170 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp POWER exp - -State 162: -## Known stack suffix: -## exp GREATER_THAN_FLOAT -## LR(1) items: -binExp -> exp GREATER_THAN_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 163 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 163: -## Known stack suffix: -## exp GREATER_THAN_FLOAT exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp GREATER_THAN_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On OPEN_PAREN shift to state 131 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp GREATER_THAN_FLOAT exp - -State 164: -## Known stack suffix: -## exp GREATER_THAN_EQUAL_FLOAT -## LR(1) items: -binExp -> exp GREATER_THAN_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 165 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 165: -## Known stack suffix: -## exp GREATER_THAN_EQUAL_FLOAT exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp GREATER_THAN_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On OPEN_PAREN shift to state 131 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp GREATER_THAN_EQUAL_FLOAT exp - -State 166: -## Known stack suffix: -## exp GREATER_THAN -## LR(1) items: -binExp -> exp GREATER_THAN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 167 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 167: -## Known stack suffix: -## exp GREATER_THAN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp GREATER_THAN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On PLUS_FLOAT shift to state 144 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On MINUS_FLOAT shift to state 148 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DIVIDE_FLOAT shift to state 170 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp GREATER_THAN exp - -State 168: -## Known stack suffix: -## exp DOUBLE_EQUAL_FLOAT -## LR(1) items: -binExp -> exp DOUBLE_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 169 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 169: -## Known stack suffix: -## exp DOUBLE_EQUAL_FLOAT exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp DOUBLE_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On OPEN_PAREN shift to state 131 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp DOUBLE_EQUAL_FLOAT exp - -State 170: -## Known stack suffix: -## exp DIVIDE_FLOAT -## LR(1) items: -binExp -> exp DIVIDE_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 171 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 171: -## Known stack suffix: -## exp DIVIDE_FLOAT exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp DIVIDE_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On OPEN_PAREN shift to state 131 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp DIVIDE_FLOAT exp - -State 172: -## Known stack suffix: -## exp PLUS -## LR(1) items: -binExp -> exp PLUS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 173 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 173: -## Known stack suffix: -## exp PLUS exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp PLUS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On PLUS_FLOAT shift to state 144 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On MINUS_FLOAT shift to state 148 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DIVIDE_FLOAT shift to state 170 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp PLUS exp - -State 174: -## Known stack suffix: -## exp NOT_EQUAL -## LR(1) items: -binExp -> exp NOT_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 175 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 175: -## Known stack suffix: -## exp NOT_EQUAL exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp NOT_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On PLUS_FLOAT shift to state 144 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On MINUS_FLOAT shift to state 148 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DIVIDE_FLOAT shift to state 170 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp NOT_EQUAL exp - -State 176: -## Known stack suffix: -## exp MINUS -## LR(1) items: -binExp -> exp MINUS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 177 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 177: -## Known stack suffix: -## exp MINUS exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp MINUS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On PLUS_FLOAT shift to state 144 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On MINUS_FLOAT shift to state 148 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DIVIDE_FLOAT shift to state 170 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp MINUS exp - -State 178: -## Known stack suffix: -## exp LESS_THAN_EQUAL -## LR(1) items: -binExp -> exp LESS_THAN_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 179 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 179: -## Known stack suffix: -## exp LESS_THAN_EQUAL exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp LESS_THAN_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On PLUS_FLOAT shift to state 144 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On MINUS_FLOAT shift to state 148 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DIVIDE_FLOAT shift to state 170 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp LESS_THAN_EQUAL exp - -State 180: -## Known stack suffix: -## exp GREATER_THAN_EQUAL -## LR(1) items: -binExp -> exp GREATER_THAN_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 181 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 181: -## Known stack suffix: -## exp GREATER_THAN_EQUAL exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp GREATER_THAN_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On PLUS_FLOAT shift to state 144 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On MINUS_FLOAT shift to state 148 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DIVIDE_FLOAT shift to state 170 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp GREATER_THAN_EQUAL exp - -State 182: -## Known stack suffix: -## exp DOUBLE_EQUAL -## LR(1) items: -binExp -> exp DOUBLE_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 183 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 183: -## Known stack suffix: -## exp DOUBLE_EQUAL exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp DOUBLE_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On PLUS_FLOAT shift to state 144 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On MINUS_FLOAT shift to state 148 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DIVIDE_FLOAT shift to state 170 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp DOUBLE_EQUAL exp - -State 184: -## Known stack suffix: -## exp DIVIDE -## LR(1) items: -binExp -> exp DIVIDE . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 185 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 185: -## Known stack suffix: -## exp DIVIDE exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp DIVIDE exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On PLUS_FLOAT shift to state 144 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On MINUS_FLOAT shift to state 148 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DIVIDE_FLOAT shift to state 170 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp DIVIDE exp - -State 186: -## Known stack suffix: -## OPEN_PAREN exp COMMA -## LR(1) items: -exp -> OPEN_PAREN exp COMMA . loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On separated_nonempty_list(COMMA,exp) shift to state 187 --- On loption(separated_nonempty_list(COMMA,exp)) shift to state 188 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 190 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,exp)) -> - -State 187: -## Known stack suffix: -## separated_nonempty_list(COMMA,exp) -## LR(1) items: -loption(separated_nonempty_list(COMMA,exp)) -> separated_nonempty_list(COMMA,exp) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,exp)) -> separated_nonempty_list(COMMA,exp) - -State 188: -## Known stack suffix: -## OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) -## LR(1) items: -exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On CLOSE_PAREN shift to state 189 -## Reductions: - -State 189: -## Known stack suffix: -## OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN -## LR(1) items: -exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN - -State 190: -## Known stack suffix: -## exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -separated_nonempty_list(COMMA,exp) -> exp . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -separated_nonempty_list(COMMA,exp) -> exp . COMMA separated_nonempty_list(COMMA,exp) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On COMMA shift to state 191 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,exp) -> exp - -State 191: -## Known stack suffix: -## exp COMMA -## LR(1) items: -separated_nonempty_list(COMMA,exp) -> exp COMMA . separated_nonempty_list(COMMA,exp) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On separated_nonempty_list(COMMA,exp) shift to state 192 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 190 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 192: -## Known stack suffix: -## exp COMMA separated_nonempty_list(COMMA,exp) -## LR(1) items: -separated_nonempty_list(COMMA,exp) -> exp COMMA separated_nonempty_list(COMMA,exp) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,exp) -> exp COMMA separated_nonempty_list(COMMA,exp) - -State 193: -## Known stack suffix: -## OPEN_PAREN exp CLOSE_PAREN -## LR(1) items: -exp -> OPEN_PAREN exp CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> OPEN_PAREN exp CLOSE_PAREN - -State 194: -## Known stack suffix: -## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) -## LR(1) items: -exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) . CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On CLOSE_SQUARE_BRACKET shift to state 195 -## Reductions: - -State 195: -## Known stack suffix: -## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET -## LR(1) items: -exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET - -State 196: -## Known stack suffix: -## exp LESS_THAN typ -## LR(1) items: -exp -> exp LESS_THAN typ . EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] -## Transitions: --- On EQUAL_ARROW shift to state 197 --- On DASH_ARROW shift to state 24 -## Reductions: - -State 197: -## Known stack suffix: -## exp LESS_THAN typ EQUAL_ARROW -## LR(1) items: -exp -> exp LESS_THAN typ EQUAL_ARROW . typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 12 --- On UNIT shift to state 14 --- On STRING_TYPE shift to state 15 --- On QUESTION shift to state 16 --- On OPEN_SQUARE_BRACKET shift to state 18 --- On OPEN_PAREN shift to state 19 --- On INT_TYPE shift to state 20 --- On FLOAT_TYPE shift to state 21 --- On BOOL_TYPE shift to state 22 --- On typ shift to state 198 -## Reductions: - -State 198: -## Known stack suffix: -## exp LESS_THAN typ EQUAL_ARROW typ -## LR(1) items: -exp -> exp LESS_THAN typ EQUAL_ARROW typ . GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ GREATER_THAN DASH_ARROW ] -## Transitions: --- On GREATER_THAN shift to state 199 --- On DASH_ARROW shift to state 24 -## Reductions: - -State 199: -## Known stack suffix: -## exp LESS_THAN typ EQUAL_ARROW typ GREATER_THAN -## LR(1) items: -exp -> exp LESS_THAN typ EQUAL_ARROW typ GREATER_THAN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> exp LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - -State 200: -## Known stack suffix: -## exp LESS_THAN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp LESS_THAN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On PLUS_FLOAT shift to state 144 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On MINUS_FLOAT shift to state 148 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DIVIDE_FLOAT shift to state 170 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp LESS_THAN exp - -State 201: -## Known stack suffix: -## exp OPEN_PAREN exp CLOSE_PAREN -## LR(1) items: -exp -> exp OPEN_PAREN exp CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> exp OPEN_PAREN exp CLOSE_PAREN - -State 202: -## Known stack suffix: -## filterAction exp IN -## LR(1) items: -exp -> filterAction exp IN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 203 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 203: -## Known stack suffix: -## filterAction exp IN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> filterAction exp IN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On L_OR shift to state 119 --- On L_AND shift to state 123 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> filterAction exp IN exp - -State 204: -## Known stack suffix: -## CASE exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -case -> CASE exp . list(rul) END [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -## Transitions: --- On TURNSTILE shift to state 205 --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 --- On rul shift to state 209 --- On list(rul) shift to state 211 -## Reductions: --- On END --- reduce production list(rul) -> - -State 205: -## Known stack suffix: -## TURNSTILE -## LR(1) items: -rul -> TURNSTILE . pat EQUAL_ARROW exp [ TURNSTILE END ] -## Transitions: --- On WILD shift to state 45 --- On TRUE shift to state 46 --- On STRING shift to state 47 --- On QUESTION shift to state 48 --- On OPEN_SQUARE_BRACKET shift to state 50 --- On OPEN_PAREN shift to state 51 --- On INT shift to state 52 --- On IDENT shift to state 53 --- On FLOAT shift to state 54 --- On FALSE shift to state 55 --- On CONSTRUCTOR_IDENT shift to state 56 --- On pat shift to state 206 -## Reductions: - -State 206: -## Known stack suffix: -## TURNSTILE pat -## LR(1) items: -pat -> pat . COLON typ [ OPEN_PAREN LESS_THAN EQUAL_ARROW CONS COLON ] -pat -> pat . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ OPEN_PAREN LESS_THAN EQUAL_ARROW CONS COLON ] -pat -> pat . CONS pat [ OPEN_PAREN LESS_THAN EQUAL_ARROW CONS COLON ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN LESS_THAN EQUAL_ARROW CONS COLON ] -rul -> TURNSTILE pat . EQUAL_ARROW exp [ TURNSTILE END ] -## Transitions: --- On OPEN_PAREN shift to state 60 --- On LESS_THAN shift to state 62 --- On EQUAL_ARROW shift to state 207 --- On CONS shift to state 67 --- On COLON shift to state 69 -## Reductions: - -State 207: -## Known stack suffix: -## TURNSTILE pat EQUAL_ARROW -## LR(1) items: -rul -> TURNSTILE pat EQUAL_ARROW . exp [ TURNSTILE END ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 208 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 208: -## Known stack suffix: -## TURNSTILE pat EQUAL_ARROW exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -rul -> TURNSTILE pat EQUAL_ARROW exp . [ TURNSTILE END ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE END --- reduce production rul -> TURNSTILE pat EQUAL_ARROW exp - -State 209: -## Known stack suffix: -## rul -## LR(1) items: -list(rul) -> rul . list(rul) [ END ] -## Transitions: --- On TURNSTILE shift to state 205 --- On rul shift to state 209 --- On list(rul) shift to state 210 -## Reductions: --- On END --- reduce production list(rul) -> - -State 210: -## Known stack suffix: -## rul list(rul) -## LR(1) items: -list(rul) -> rul list(rul) . [ END ] -## Transitions: -## Reductions: --- On END --- reduce production list(rul) -> rul list(rul) - -State 211: -## Known stack suffix: -## CASE exp list(rul) -## LR(1) items: -case -> CASE exp list(rul) . END [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On END shift to state 212 -## Reductions: - -State 212: -## Known stack suffix: -## CASE exp list(rul) END -## LR(1) items: -case -> CASE exp list(rul) END . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production case -> CASE exp list(rul) END - -State 213: -## Known stack suffix: -## DOLLAR_SIGN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -unExp -> DOLLAR_SIGN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On L_OR shift to state 119 --- On L_AND shift to state 123 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production unExp -> DOLLAR_SIGN exp - -State 214: -## Known stack suffix: -## FIX pat DASH_ARROW exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> FIX pat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> FIX pat DASH_ARROW exp - -State 215: -## Known stack suffix: -## FUN pat DASH_ARROW exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -funExp -> FUN pat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production funExp -> FUN pat DASH_ARROW exp - -State 216: -## Known stack suffix: -## IF exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> IF exp . THEN exp ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On THEN shift to state 217 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: - -State 217: -## Known stack suffix: -## IF exp THEN -## LR(1) items: -exp -> IF exp THEN . exp ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 218 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 218: -## Known stack suffix: -## IF exp THEN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> IF exp THEN exp . ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On ELSE shift to state 219 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: - -State 219: -## Known stack suffix: -## IF exp THEN exp ELSE -## LR(1) items: -exp -> IF exp THEN exp ELSE . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 220 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 220: -## Known stack suffix: -## IF exp THEN exp ELSE exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> IF exp THEN exp ELSE exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> IF exp THEN exp ELSE exp - -State 221: -## Known stack suffix: -## LESS_THAN LESS_THAN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> LESS_THAN LESS_THAN exp . QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 222 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: - -State 222: -## Known stack suffix: -## LESS_THAN LESS_THAN exp QUESTION -## LR(1) items: -exp -> exp QUESTION . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> LESS_THAN LESS_THAN exp QUESTION . SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEXP_STRING shift to state 223 --- On LESS_THAN shift to state 126 -## Reductions: - -State 223: -## Known stack suffix: -## LESS_THAN LESS_THAN exp QUESTION SEXP_STRING -## LR(1) items: -exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING . GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On GREATER_THAN shift to state 224 -## Reductions: - -State 224: -## Known stack suffix: -## LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN -## LR(1) items: -exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN . GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On GREATER_THAN shift to state 225 -## Reductions: - -State 225: -## Known stack suffix: -## LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN -## LR(1) items: -exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN - -State 226: -## Known stack suffix: -## LET pat SINGLE_EQUAL exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> LET pat SINGLE_EQUAL exp . IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On IN shift to state 227 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: - -State 227: -## Known stack suffix: -## LET pat SINGLE_EQUAL exp IN -## LR(1) items: -exp -> LET pat SINGLE_EQUAL exp IN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 9 --- On TRUE shift to state 35 --- On TEST shift to state 36 --- On STRING shift to state 37 --- On QUESTION shift to state 38 --- On PAUSE shift to state 40 --- On OPEN_SQUARE_BRACKET shift to state 41 --- On OPEN_PAREN shift to state 42 --- On NAMED_FUN shift to state 43 --- On MINUS shift to state 84 --- On L_NOT shift to state 85 --- On LET shift to state 86 --- On LESS_THAN shift to state 89 --- On INT shift to state 91 --- On IF shift to state 92 --- On IDENT shift to state 93 --- On HIDE shift to state 94 --- On FUN shift to state 95 --- On FLOAT shift to state 98 --- On FIX shift to state 99 --- On FALSE shift to state 102 --- On EVAL shift to state 103 --- On DOLLAR_SIGN shift to state 104 --- On DEBUG shift to state 105 --- On CONSTRUCTOR_IDENT shift to state 106 --- On CASE shift to state 109 --- On BUILTIN shift to state 110 --- On unExp shift to state 111 --- On funExp shift to state 112 --- On filterAction shift to state 113 --- On exp shift to state 228 --- On case shift to state 121 --- On binExp shift to state 122 -## Reductions: - -State 228: -## Known stack suffix: -## LET pat SINGLE_EQUAL exp IN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> LET pat SINGLE_EQUAL exp IN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> LET pat SINGLE_EQUAL exp IN exp - -State 229: -## Known stack suffix: -## L_NOT exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -unExp -> L_NOT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production unExp -> L_NOT exp - -State 230: -## Known stack suffix: -## MINUS exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -unExp -> MINUS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On PLUS_FLOAT shift to state 144 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On MINUS_FLOAT shift to state 148 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DIVIDE_FLOAT shift to state 170 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production unExp -> MINUS exp - -State 231: -## Known stack suffix: -## NAMED_FUN IDENT pat DASH_ARROW exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -funExp -> NAMED_FUN IDENT pat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production funExp -> NAMED_FUN IDENT pat DASH_ARROW exp - -State 232: -## Known stack suffix: -## TEST exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> TEST exp . END [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On END shift to state 233 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: - -State 233: -## Known stack suffix: -## TEST exp END -## LR(1) items: -exp -> TEST exp END . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> TEST exp END - -State 234: -## Known stack suffix: -## TYP tpat SINGLE_EQUAL typ IN exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> TYP tpat SINGLE_EQUAL typ IN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On L_OR shift to state 119 --- On L_AND shift to state 123 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> TYP tpat SINGLE_EQUAL typ IN exp - -State 235: -## Known stack suffix: -## TYP_FUN tpat DASH_ARROW exp -## LR(1) items: -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> TYP_FUN tpat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: --- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> TYP_FUN tpat DASH_ARROW exp - -State 236: -## Known stack suffix: -## program -## LR(1) items: -program' -> program . [ # ] -## Transitions: -## Reductions: --- On # --- accept program - -State 237: -## Known stack suffix: -## exp -## LR(1) items: -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . QUESTION LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . LESS_THAN typ EQUAL_ARROW typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -program -> exp . EOF [ # ] -## Transitions: --- On TIMES_FLOAT shift to state 115 --- On TIMES shift to state 133 --- On SEMI_COLON shift to state 117 --- On QUESTION shift to state 125 --- On POWER_FLOAT shift to state 135 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 144 --- On PLUS shift to state 172 --- On OPEN_PAREN shift to state 131 --- On NOT_EQUAL_FLOAT shift to state 146 --- On NOT_EQUAL shift to state 174 --- On MINUS_FLOAT shift to state 148 --- On MINUS shift to state 176 --- On L_OR shift to state 119 --- On L_AND shift to state 123 --- On LESS_THAN_FLOAT shift to state 150 --- On LESS_THAN_EQUAL_FLOAT shift to state 152 --- On LESS_THAN_EQUAL shift to state 178 --- On LESS_THAN shift to state 154 --- On GREATER_THAN_FLOAT shift to state 162 --- On GREATER_THAN_EQUAL_FLOAT shift to state 164 --- On GREATER_THAN_EQUAL shift to state 180 --- On GREATER_THAN shift to state 166 --- On EOF shift to state 238 --- On DOUBLE_EQUAL_FLOAT shift to state 168 --- On DOUBLE_EQUAL shift to state 182 --- On DIVIDE_FLOAT shift to state 170 --- On DIVIDE shift to state 184 --- On CONS shift to state 137 --- On AT_SYMBOL shift to state 139 -## Reductions: - -State 238: -## Known stack suffix: -## exp EOF -## LR(1) items: -program -> exp EOF . [ # ] -## Transitions: -## Reductions: --- On # --- reduce production program -> exp EOF - diff --git a/src/haz3lmenhir/Parser.conflicts b/src/haz3lmenhir/Parser.conflicts deleted file mode 100644 index 17bed598d3..0000000000 --- a/src/haz3lmenhir/Parser.conflicts +++ /dev/null @@ -1,33 +0,0 @@ - -** Conflict (reduce/reduce) in state 156. -** Tokens involved: COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN -** The following explanations concentrate on token CLOSE_SQUARE_BRACKET. -** This state is reached from program after reading: - -exp LESS_THAN OPEN_SQUARE_BRACKET QUESTION STRING - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -(?) - -** In state 156, looking ahead at CLOSE_SQUARE_BRACKET, reducing production -** exp -> QUESTION STRING -** is permitted because of the following sub-derivation: - -binExp -exp LESS_THAN exp - OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET // lookahead token appears - separated_nonempty_list(COMMA,exp) // lookahead token is inherited - exp // lookahead token is inherited - QUESTION STRING . - -** In state 156, looking ahead at CLOSE_SQUARE_BRACKET, reducing production -** typ -> QUESTION STRING -** is permitted because of the following sub-derivation: - -exp LESS_THAN typ EQUAL_ARROW typ GREATER_THAN - OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET // lookahead token appears - QUESTION STRING . diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 280a79d1b9..fb977b256a 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -174,6 +174,7 @@ binExp: | e1 = exp; b = binOp; e2 = exp { BinExp (e1, b, e2) } typ: + | c = CONSTRUCTOR_IDENT { Var(c) } | QUESTION; T_TYP; s = STRING { InvalidTyp(s) } | INT_TYPE { IntType } | FLOAT_TYPE { FloatType } diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 9fcd8746b5..f90effb1cf 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -280,12 +280,12 @@ let tests = [ "A ~ Int", ), // TODO Fix for the tests below - skip_menhir_only_test( + menhir_only_test( "Constructor with Type Variable", Constructor("A", Var("T") |> Typ.fresh) |> Exp.fresh, "A ~ T", ), - skip_parser_test( + parser_test( "Type Variable", Let( Cast( From decb9ec434b6abff77b0addea7547887fec9999e Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 25 Nov 2024 10:03:06 -0500 Subject: [PATCH 084/281] Fix assert message for parser_test when menhir fails --- test/Test_Menhir.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index f90effb1cf..5711167741 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -21,7 +21,7 @@ let make_term_parse = (s: string) => let menhir_matches = (name: string, exp: Term.Exp.t, actual: string) => alco_check( - name ++ " matches expected type", + name ++ " menhir matches expected type", exp, Haz3lmenhir.Conversion.Exp.of_menhir_ast( Haz3lmenhir.Interface.parse_program(actual), From 807dc8f406d6b9013b673a238144450e85aa3d99 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 25 Nov 2024 11:49:02 -0500 Subject: [PATCH 085/281] Some changed to the menhir parser for int operations --- src/haz3lmenhir/Parser.mly | 20 +++++++++++++++++--- test/Test_Menhir.re | 34 +++++++++++++++++++++++++--------- 2 files changed, 42 insertions(+), 12 deletions(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index fb977b256a..e3c8ae8280 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -51,9 +51,9 @@ open AST %token NOT_EQUAL %token PLUS %token MINUS -%token DIVIDE %token POWER %token TIMES +%token DIVIDE %token LESS_THAN %token LESS_THAN_EQUAL %token GREATER_THAN @@ -105,11 +105,25 @@ open AST %left DASH_ARROW -%left PLUS MINUS TIMES POWER DIVIDE DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL + +(* Int op precedences *) +%left DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL + +%left PLUS MINUS +%left DIVIDE TIMES +%right POWER %left GREATER_THAN LESS_THAN -%left PLUS_FLOAT MINUS_FLOAT TIMES_FLOAT POWER_FLOAT DIVIDE_FLOAT DOUBLE_EQUAL_FLOAT NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT +(* End of int op precedences *) + +(* Float op precedences *) + +%left DOUBLE_EQUAL_FLOAT NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT + +%left PLUS_FLOAT MINUS_FLOAT +%left TIMES_FLOAT DIVIDE_FLOAT +%right POWER_FLOAT (* Other *) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index f90effb1cf..e9de679242 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -39,15 +39,14 @@ let skip_menhir_only_test = (name: string, _exp: Term.Exp.t, _actual: string) => // TODO Assert against result instead of exception for parse failure for better error messages let parser_test = (name: string, exp: Term.Exp.t, actual: string) => - test_case( - name, - `Quick, - () => { - alco_check("Does not match MakeTerm", exp, make_term_parse(actual)); - - menhir_matches(name, exp, actual); - }, - ); + test_case(name, `Quick, () => { + // alco_check("Does not match MakeTerm", exp, make_term_parse(actual)); + menhir_matches( + name, + exp, + actual, + ) + }); let menhir_maketerm_equivalent_test = (name: string, actual: string) => test_case(name, `Quick, () => { @@ -364,6 +363,23 @@ let tests = [ |> Exp.fresh, "-1 + 2 - 3 / 4 * 5 ** 6 >= 8", ), // TODO Add the remaining operators and fix precedence + parser_test( + "simple pemdas", + BinOp( + Int(Times), + BinOp(Int(Times), Int(3) |> Exp.fresh, Int(4) |> Exp.fresh) + |> Exp.fresh, + BinOp( + Int(Power), + Int(4) |> Exp.fresh, + BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) + |> Exp.fresh, + ) + |> Exp.fresh, + ) + |> Exp.fresh, + "3 / 4 * 5 ** 6", + ), parser_test("Float", Float(1.) |> Exp.fresh, "1."), skip_parser_test( "Float Ops", From 033bda3a97aafd05e9ada3032da53cedc7080153 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Tue, 26 Nov 2024 11:57:02 -0500 Subject: [PATCH 086/281] Modifications to the menhir testing to fix the float ops testing and changed the lexer to handle float minus --- src/haz3lmenhir/Lexer.mll | 13 ++++++--- test/Test_Menhir.re | 55 ++++++++++++--------------------------- 2 files changed, 27 insertions(+), 41 deletions(-) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index eea05e16e6..2c2e0b0e50 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -9,8 +9,15 @@ let advance_line lexbuf = pos_lnum = pos.pos_lnum + 1 } in lexbuf.lex_curr_p <- pos' -} +let parse_float_string s = + try + let f = float_of_string s in + f + with + | Failure _ -> print_endline ("Parse Float String Lexing Error On: " ^ s); 0.0 + +} let float = '-'? ['0'-'9']* '.' ['0'-'9']* let int = '-'? ['0'-'9'] ['0'-'9']* @@ -30,10 +37,11 @@ rule token = parse | "undef" { UNDEF} | "infinity" | "neg_infinity" | "nan" | "epsilon_float" | "pi" | "max_int" | "min_int" | "is_finite" | "is_infinite" | "int_of_float" | "float_of_int" | "string_of_int" | "string_of_float" | "string_of_bool" | "int_of_string" | "float_of_string" | "bool_of_string" | "abs" | "abs_float" | "ceil" | "floor" | "exp" | "log" | "log10" | "sqrt" | "sin" | "cos" | "tan" | "asin" | "acos" | "atan" | "mod" | "string_length" | "string_compare" | "string_trim" | "string_concat" | "string_sub" { BUILTIN(Lexing.lexeme lexbuf)} + | "-." { MINUS_FLOAT } | whitespace {token lexbuf } | newline { advance_line lexbuf; token lexbuf} | ints as i { INT (int_of_string i) } - | float as f { FLOAT (float_of_string f )} + | float as f { FLOAT (parse_float_string f )} | string as s { STRING (String.sub s 1 (String.length s - 2)) } | sexp_string as s { SEXP_STRING (String.sub s 1 (String.length s - 2)) } | "true" { TRUE } @@ -67,7 +75,6 @@ rule token = | ">=" { GREATER_THAN_EQUAL } (* Float ops *) | "+." { PLUS_FLOAT } - | "-." { MINUS_FLOAT } | "*." { TIMES_FLOAT } | "/." { DIVIDE_FLOAT } | "**." {POWER_FLOAT} diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 3a18f6ea12..f3e2be1191 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -332,7 +332,7 @@ let tests = [ |> Exp.fresh, "[1, 2] @ [3, 4]", ), - skip_parser_test( + parser_test( "Integer Ops", BinOp( Int(GreaterThanOrEqual), @@ -345,14 +345,10 @@ let tests = [ ) |> Exp.fresh, BinOp( - Int(Divide), - Int(3) |> Exp.fresh, - BinOp( - Int(Times), - Int(4) |> Exp.fresh, - BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) - |> Exp.fresh, - ) + Int(Times), + BinOp(Int(Divide), Int(3) |> Exp.fresh, Int(4) |> Exp.fresh) + |> Exp.fresh, + BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) |> Exp.fresh, ) |> Exp.fresh, @@ -362,44 +358,27 @@ let tests = [ ) |> Exp.fresh, "-1 + 2 - 3 / 4 * 5 ** 6 >= 8", - ), // TODO Add the remaining operators and fix precedence - parser_test( - "simple pemdas", - BinOp( - Int(Times), - BinOp(Int(Times), Int(3) |> Exp.fresh, Int(4) |> Exp.fresh) - |> Exp.fresh, - BinOp( - Int(Power), - Int(4) |> Exp.fresh, - BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) - |> Exp.fresh, - ) - |> Exp.fresh, - ) - |> Exp.fresh, - "3 / 4 * 5 ** 6", ), parser_test("Float", Float(1.) |> Exp.fresh, "1."), - skip_parser_test( + parser_test( "Float Ops", BinOp( Float(LessThan), BinOp( - Float(Plus), + Float(Minus), Float(2.) |> Exp.fresh, BinOp( - Float(Divide), - Float(3.) |> Exp.fresh, + Float(Times), BinOp( - Float(Times), + Float(Divide), + Float(3.) |> Exp.fresh, Float(4.) |> Exp.fresh, - BinOp( - Float(Power), - Float(5.) |> Exp.fresh, - Float(6.) |> Exp.fresh, - ) - |> Exp.fresh, + ) + |> Exp.fresh, + BinOp( + Float(Power), + Float(5.) |> Exp.fresh, + Float(6.) |> Exp.fresh, ) |> Exp.fresh, ) @@ -409,7 +388,7 @@ let tests = [ Float(8.) |> Exp.fresh, ) |> Exp.fresh, - "2. +. 3. /. 4. *. 5. **. 6. <. 8." // TODO Add the remaining operators. -. is also currently broken + "2. -. 3. /. 4. *. 5. **. 6. <. 8." // TODO Add the remaining operators. -. is also currently broken ), parser_test( "Let binding with type ascription", From 13e968ff25ff908ba2514a4645ee9cba9b19f5a3 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sat, 30 Nov 2024 23:09:36 -0500 Subject: [PATCH 087/281] Started to add sum types to the menhir parser & temporarily changed menhir casting syntax --- basic_reference.txt | 118 ++++++++++++++++++++++++++++++++++ src/haz3lmenhir/AST.re | 7 ++ src/haz3lmenhir/Conversion.re | 10 +++ src/haz3lmenhir/Lexer.mll | 5 ++ src/haz3lmenhir/Parser.mly | 31 +++++++-- test/Test_Menhir.re | 38 ++++++----- 6 files changed, 189 insertions(+), 20 deletions(-) create mode 100644 basic_reference.txt diff --git a/basic_reference.txt b/basic_reference.txt new file mode 100644 index 0000000000..8c3ae8ad0a --- /dev/null +++ b/basic_reference.txt @@ -0,0 +1,118 @@ + + + +let empty_hole = ? in + + + +let non_empty_hole : Int = true in + + +let bool: Bool = true in +let operators = !true && false || true in +let conditional = if !true then 1 else 2 in + + +let num: Int = 1 in +let arithmetic = -num*1 + 2/3 - 4**5 in +let comparison = +(0 == 0, 0 < 1, 1 <= 1, 2 > 1, 1 >= 1) +in + + +let float: Float = 0.1 in +let artihmetic = 0. *. 1. +. 2. /. 3. -. 4. **. 5. in +let comparison = +(0. ==. 0., 0. <. 1., 1. <=. 1., 2. >. 1., 1. >=. 1.) +in + + +let string = "Hello, world!" in +let concatenation = string ++ " Goodbye." in +let comparison = string$== "Hello, world!" in + + +let tuple : (Int, Bool, (Bool, Int)) = +(1, true, (false, 3)) in +let (a, b, (c, d)) = tuple in + + +let y : (Int, Int, Int) -> Int = +fun (m, x, b) -> m * x + b in + + +let double_recursively : Int -> Int = +fun n -> +if n == 0 +then 0 +else double_recursively(n - 1) + 2 +in + + +let (even : Int -> Bool, odd : Int -> Bool) = +(fun n -> if n == 0 then true else odd(n - 1), +fun n -> if n == 0 then false else even(n - 1)) +in + + +let empty_list : [Int] = [] in +let non_empty_list : [Int] = 1::2::3::[] in +let list_literals : [Int] = [1, 2, 3] in +let length : [Int] -> Int = +fun xs -> +case xs +| [] => 0 +| hd::tl => 1 + length(tl) +end +in +let has_at_least_two_elements : [Int] -> Bool = +fun xs -> +case xs +| [] => false +| hd::[] => false +| a::b::[] => true +end +in + + +type Exp = ++ Var(String) ++ Lam(String, Exp) ++ Ap(Exp, Exp) in +let exp_equal: (Exp, Exp) -> Bool = +fun es -> +case es +| Var(x), Var(y) => x$== y +| Lam(x1, e1), Lam(x2, e2) => +x1$== x2 && exp_equal(e1, e2) +| Ap(e1, e2), Ap(e3, e4) => +exp_equal(e1, e3) && exp_equal(e2, e4) +| _ => false +end +in + + +let poly_id: forall a -> a -> a = +typfun a -> fun x : a -> x +in +let apply_both: +forall a -> forall b -> (forall c -> c -> c) -> ((a, b) -> (a, b)) = +typfun a -> typfun b -> +fun f : forall c -> (c -> c) -> +fun (x, y) : (a, b) -> (f@(x), f@(y)) +in +let list_length: forall a -> [a] -> Int = +typfun a -> fun l : [a] -> +case l +| [] => 0 +| hd::tl => 1 + list_length@(tl) +end +in + + +test 2 + 2 == 4 end; +test 3 + 3 == 6 end; +test 2 + 2 == 5 end; + + +2 + 2 diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 54db1bddc8..e7195191e2 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -40,10 +40,16 @@ type op_bin_int = | Equals | NotEquals; +[@deriving (show({with_path: false}), sexp)] +type op_bin_string = + | Concat + | Equals; + [@deriving (show({with_path: false}), sexp)] type binOp = | IntOp(op_bin_int) | FloatOp(op_bin_float) + | StringOp(op_bin_string) | BoolOp(op_bin_bool); [@deriving (show({with_path: false}), sexp)] @@ -75,6 +81,7 @@ type typ = | FloatType | BoolType | UnitType + | SumType(list((string, list(typ)))) | UnknownType(typ_provenance) | TupleType(list(typ)) | ArrayType(typ) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index fd5e16192f..3635f24300 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -57,6 +57,14 @@ module Operators = { }; }; + [@deriving (show({with_path: false}), sexp, yojson)] + let string_op_of_menhir_ast = (op: AST.op_bin_string): op_bin_string => { + switch (op) { + | Concat => Concat + | Equals => Equals + }; + }; + [@deriving (show({with_path: false}), sexp, yojson)] let bool_op_of_menhir_ast = (op: AST.op_bin_bool): op_bin_bool => { switch (op) { @@ -88,6 +96,7 @@ module Operators = { | IntOp(op_int) => Int(int_op_of_menhir_ast(op_int)) | FloatOp(op_float) => Float(float_op_of_menhir_ast(op_float)) | BoolOp(op_bool) => Bool(bool_op_of_menhir_ast(op_bool)) + | StringOp(op_string) => String(string_op_of_menhir_ast(op_string)) }; }; }; @@ -229,6 +238,7 @@ and Typ: { | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) | ArrayType(t) => List(of_menhir_ast(t)) | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) + | SumType(_l) => raise(Failure("SumType not implemented")) }; }; } diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index 2c2e0b0e50..e31c8e83d6 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -56,6 +56,8 @@ rule token = | "else" { ELSE } | "[" { OPEN_SQUARE_BRACKET } | "]" { CLOSE_SQUARE_BRACKET } + | "{" { OPEN_CURLY } + | "}" { CLOSE_CURLY } | "(" { OPEN_PAREN } | ")" { CLOSE_PAREN } | "->" { DASH_ARROW } @@ -84,6 +86,9 @@ rule token = | "<=." { LESS_THAN_EQUAL_FLOAT } | ">." { GREATER_THAN_FLOAT } | ">=." { GREATER_THAN_EQUAL_FLOAT } + (* String Ops *) + | "++" { STRING_CONCAT } + | "$==" { STRING_EQUAL } (* Bool ops *) | "&&" { L_AND } | "||" { L_OR } diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index e3c8ae8280..12ef8cba5d 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -4,7 +4,8 @@ open AST - +%token OPEN_CURLY +%token CLOSE_CURLY %token T_TYP %token P_PAT %token TP_TPAT @@ -46,6 +47,10 @@ open AST %token SINGLE_EQUAL %token TURNSTILE +(* String ops *) +%token STRING_CONCAT +%token STRING_EQUAL + (* Int ops *) %token DOUBLE_EQUAL %token NOT_EQUAL @@ -103,6 +108,7 @@ open AST %nonassoc IF_EXP %nonassoc LET_EXP +%left COLON %left DASH_ARROW @@ -125,12 +131,12 @@ open AST %left TIMES_FLOAT DIVIDE_FLOAT %right POWER_FLOAT +%left OPEN_CURLY (* Other *) %left CONS %left OPEN_PAREN %left QUESTION -%left COLON %left TILDE (* %left COMMA *) %left AT_SYMBOL @@ -139,6 +145,9 @@ open AST %left DOLLAR_SIGN %left L_NOT L_AND L_OR + +%left STRING_CONCAT STRING_EQUAL + %type exp %start program @@ -179,14 +188,24 @@ program: | L_AND { BoolOp(And) } | L_OR { BoolOp(Or) } +%inline stringOp: + | STRING_CONCAT { StringOp(Concat) } + | STRING_EQUAL { StringOp(Equals) } + %inline binOp: | i = intOp { i } | f = floatOp { f } | b = boolOp { b } + | s = stringOp { s } binExp: | e1 = exp; b = binOp; e2 = exp { BinExp (e1, b, e2) } +(* sumTerm: *) +(* | PLUS; i = CONSTRUCTOR_IDENT; OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { (i, types) } *) + + + typ: | c = CONSTRUCTOR_IDENT { Var(c) } | QUESTION; T_TYP; s = STRING { InvalidTyp(s) } @@ -199,10 +218,11 @@ typ: | OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { TupleType(types) } | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } | t1 = typ; DASH_ARROW; t2 = typ { ArrowType(t1, t2) } + (* | l = list(sumTerm) { SumType(l) } *) pat: | p1 = pat; COLON; t1 = typ; { CastPat(p1, t1, UnknownType(Internal)) } - | p1 = pat; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { CastPat(p1, t1, t2) } + | p1 = pat; OPEN_CURLY; t1 = typ; EQUAL_ARROW; t2 = typ; CLOSE_CURLY { CastPat(p1, t1, t2) } | OPEN_PAREN; p = pat; CLOSE_PAREN { p } | OPEN_PAREN; p = pat; COMMA; pats = separated_list(COMMA, pat); CLOSE_PAREN { TuplePat(p :: pats) } | QUESTION; P_PAT; s = STRING { InvalidPat(s) } @@ -246,6 +266,7 @@ tpat: | QUESTION; TP_TPAT; s = STRING {InvalidTPat(s)} | QUESTION {EmptyHoleTPat} | v = IDENT {VarTPat v} + | v = CONSTRUCTOR_IDENT {VarTPat v} unExp: | DOLLAR_SIGN; e = exp {UnOp(Meta(Unquote), e)} @@ -269,8 +290,8 @@ exp: | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } %prec LET_EXP | i = ifExp { i } - | e1 = exp; QUESTION; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN {FailedCast(e1, t1, t2)} - | e1 = exp; LESS_THAN; t1 = typ; EQUAL_ARROW; t2 = typ; GREATER_THAN { Cast(e1, t1, t2) } + | e1 = exp; QUESTION; OPEN_CURLY; t1 = typ; EQUAL_ARROW; t2 = typ; CLOSE_CURLY {FailedCast(e1, t1, t2)} + | e1 = exp; OPEN_CURLY; t1 = typ; EQUAL_ARROW; t2 = typ; CLOSE_CURLY { Cast(e1, t1, t2) } | TRUE { Bool true } | f = funExp {f} | FALSE { Bool false } diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index f3e2be1191..65dbdec840 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -388,7 +388,7 @@ let tests = [ Float(8.) |> Exp.fresh, ) |> Exp.fresh, - "2. -. 3. /. 4. *. 5. **. 6. <. 8." // TODO Add the remaining operators. -. is also currently broken + "2. -. 3. /. 4. *. 5. **. 6. <. 8.", ), parser_test( "Let binding with type ascription", @@ -418,6 +418,16 @@ let tests = [ "named_fun f x -> x + 5", ), { + // parser_test( + // "Partial basic_reference test", + // Int(5) |> Exp.fresh, + // " + // let y : (Int, Int, Int) -> Int = + // fun (m, x, b) -> m * x + b in + // 1 + // ", + // ), + let strip_comments = str => { let re = Str.regexp("#[^#]*#"); Str.global_replace(re, "", str); @@ -434,19 +444,17 @@ let tests = [ |> (slide => strip_comments(slide.backup_text)) |> replace_holes; - test_case( - "Basic Reference", - `Quick, - () => { - let _ = Alcotest.skip(); - alco_check( - "Does not match MakeTerm", - make_term_parse(basic_reference), - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(basic_reference), - ), - ); - }, - ); + print_endline(basic_reference); + + test_case("Basic Reference", `Quick, () => { + // let _ = Alcotest.skip(); + alco_check( + "Does not match MakeTerm", + make_term_parse(basic_reference), + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(basic_reference), + ), + ) + }); }, ]; From 24a4588eb76d50f0f60b89d2659c1fa0420e8df2 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sat, 30 Nov 2024 23:14:34 -0500 Subject: [PATCH 088/281] Updated menhir elaboration tests to match new menhir casting syntax --- test/Test_Elaboration.re | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index f6ebf55a83..6f627b8fec 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -430,7 +430,7 @@ let f = BinOp(Int(Plus), Bool(false) |> Exp.fresh, Var("y") |> Exp.fresh) |> Exp.fresh; - let bin_op_str = "false? Int> + y Int>"; + let bin_op_str = "false?{Bool => Int} + y{Unknown Internal => Int}"; let bin_op_menhir = () => alco_check_menhir( @@ -442,8 +442,8 @@ let f = //Inconsistent branches menhir test let inconsistent_case_menhir_str = " case 4 == 3 - | true => 24 Unknown Internal> - | false => false Unknown Internal> + | true => 24{Int => Unknown Internal} + | false => false{Bool => Unknown Internal} end "; let inconsistent_case_uexp: Exp.t = @@ -544,7 +544,7 @@ let f = let typ_ap_menhir = () => alco_check_menhir("Type ap test (menhir)", typ_ap_str, typ_ap_uexp); - let failed_cast_str = "1 ? String>"; + let failed_cast_str = "1 ?{Int => String}"; let failed_cast_uexp: Exp.t = FailedCast(Int(1) |> Exp.fresh, Int |> Typ.fresh, String |> Typ.fresh) |> Exp.fresh; @@ -568,7 +568,7 @@ let f = /* <<1 / 2 ? `a`>> */ - let dynamic_error_hole_str = "<<(1/0) ? `DivideByZero`>> Int>"; + let dynamic_error_hole_str = "<<(1/0) ? `DivideByZero`>> {Unknown Internal => Int}"; let dynamic_error_hole_uexp: Exp.t = { ids: [id_at(0)], term: @@ -604,7 +604,7 @@ let f = let undef_menhir = () => alco_check_menhir("Undef test (menhir)", undef_str, undef_uexp); - let test_str = "test 1 ? Bool> end"; + let test_str = "test 1 ?{Int => Bool} end"; let test_uexp: Exp.t = { ids: [id_at(0)], term: Test(Int(1) |> Exp.fresh), @@ -734,7 +734,7 @@ x let seq_menhir = () => alco_check_menhir("Sequence test (menhir)", seq_str, seq_uexp); - let fixf_str = "fix x -> 1 Unknown Internal>"; + let fixf_str = "fix x -> 1{Int => Unknown Internal}"; let fixf_uexp: Exp.t = { ids: [id_at(0)], term: FixF(Var("x") |> Pat.fresh, Int(1) |> Exp.fresh, None), From 6d816f459a63460458ff912562817b99e1fed0ca Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sun, 1 Dec 2024 14:08:47 -0500 Subject: [PATCH 089/281] Fixed the shift/reduce conflict with the sum types in the menhir parser --- src/haz3lmenhir/AST.re | 5 +++-- src/haz3lmenhir/Conversion.re | 5 +++-- src/haz3lmenhir/Parser.mly | 20 ++++++++++++++------ 3 files changed, 20 insertions(+), 10 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index e7195191e2..a5d113a3e8 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -81,12 +81,13 @@ type typ = | FloatType | BoolType | UnitType - | SumType(list((string, list(typ)))) + | SumTyp(typ, option(typ)) + | SumTerm(string, list(typ)) | UnknownType(typ_provenance) | TupleType(list(typ)) | ArrayType(typ) | ArrowType(typ, typ) - | Var(string) + | TypVar(string) | InvalidTyp(string); [@deriving (show({with_path: false}), sexp)] diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 3635f24300..f68f4b8789 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -234,11 +234,12 @@ and Typ: { switch (p) { | Internal => Unknown(Internal) } - | Var(s) => Var(s) + | TypVar(s) => Var(s) | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) | ArrayType(t) => List(of_menhir_ast(t)) | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) - | SumType(_l) => raise(Failure("SumType not implemented")) + | SumTyp(_) => raise(Failure("SumType not implemented")) + | SumTerm(_) => raise(Failure("SumTerm conversion not implemented")) }; }; } diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 12ef8cba5d..e32ec52268 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -105,13 +105,17 @@ open AST (* Precedences *) + + %nonassoc IF_EXP %nonassoc LET_EXP +%right SUM_TYP + + %left COLON %left DASH_ARROW - (* Int op precedences *) %left DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL @@ -146,6 +150,7 @@ open AST %left L_NOT L_AND L_OR + %left STRING_CONCAT STRING_EQUAL %type exp @@ -158,8 +163,8 @@ program: | e = exp; EOF {e} %inline intOp: - | PLUS { IntOp(Plus) } | MINUS { IntOp(Minus) } + | PLUS { IntOp(Plus) } | TIMES { IntOp(Times) } | POWER { IntOp(Power) } | DIVIDE { IntOp(Divide) } @@ -201,13 +206,16 @@ program: binExp: | e1 = exp; b = binOp; e2 = exp { BinExp (e1, b, e2) } -(* sumTerm: *) -(* | PLUS; i = CONSTRUCTOR_IDENT; OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { (i, types) } *) +%inline sumTerm: + | i = CONSTRUCTOR_IDENT; OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { SumTerm(i, types) } +sumTyp: + | PLUS; s = sumTerm; { SumTyp(s, None) } %prec SUM_TYP + | PLUS; s = sumTerm; t = sumTyp { SumTyp(s, Some(t)) } typ: - | c = CONSTRUCTOR_IDENT { Var(c) } + | c = CONSTRUCTOR_IDENT { TypVar(c) } | QUESTION; T_TYP; s = STRING { InvalidTyp(s) } | INT_TYPE { IntType } | FLOAT_TYPE { FloatType } @@ -218,7 +226,7 @@ typ: | OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { TupleType(types) } | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } | t1 = typ; DASH_ARROW; t2 = typ { ArrowType(t1, t2) } - (* | l = list(sumTerm) { SumType(l) } *) + | s = sumTyp; { s } pat: | p1 = pat; COLON; t1 = typ; { CastPat(p1, t1, UnknownType(Internal)) } From 8335bfe1f2d93f166cfdeed313cfd1637f752e0a Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sun, 1 Dec 2024 14:38:35 -0500 Subject: [PATCH 090/281] Added initial version of menhir sum type -> hazel sum type conversion --- src/haz3lmenhir/AST.re | 2 +- src/haz3lmenhir/Conversion.re | 41 +++++++++++++++++++++++++++++++++-- src/haz3lmenhir/Parser.mly | 8 +++++-- 3 files changed, 46 insertions(+), 5 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index a5d113a3e8..ca59e5a815 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -82,7 +82,7 @@ type typ = | BoolType | UnitType | SumTyp(typ, option(typ)) - | SumTerm(string, list(typ)) + | SumTerm(string, typ) | UnknownType(typ_provenance) | TupleType(list(typ)) | ArrayType(typ) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index f68f4b8789..5924f9c428 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -218,6 +218,11 @@ module rec Exp: { } and Typ: { let of_menhir_ast: AST.typ => Haz3lcore.Typ.t; + let constructormap_of_sumterm_list: + list(AST.typ) => Haz3lcore.ConstructorMap.t(Haz3lcore.Typ.t); + + let constructormap_variant_of_sumterm: + AST.typ => Haz3lcore.ConstructorMap.variant(Haz3lcore.Typ.t); } = { let rec of_menhir_ast = (typ: AST.typ): Haz3lcore.Typ.t => { Haz3lcore.IdTagged.fresh(term_of_menhir_ast(typ)); @@ -238,8 +243,40 @@ and Typ: { | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) | ArrayType(t) => List(of_menhir_ast(t)) | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) - | SumTyp(_) => raise(Failure("SumType not implemented")) - | SumTerm(_) => raise(Failure("SumTerm conversion not implemented")) + | SumTyp(term, next) => + let terms = ref([term]); + let rec go = (next: option(AST.typ)): list(AST.typ) => { + switch (next) { + | Some(t) => + switch (t) { + | SumTyp(term, next) => + terms := [term, ...terms^]; + go(next); + | _ => raise(Failure("SumTyp conversion failure")) + } + | None => terms^ + }; + }; + let _ = go(next); + let converted_terms = constructormap_of_sumterm_list(terms^); + Sum(converted_terms); + | SumTerm(_) => raise(Failure("SumTerm conversion not possible")) + }; + } + and constructormap_of_sumterm_list = + (terms: list(AST.typ)): Haz3lcore.ConstructorMap.t(Haz3lcore.Typ.t) => { + List.map(constructormap_variant_of_sumterm, terms); + } + and constructormap_variant_of_sumterm = + (term: AST.typ): Haz3lcore.ConstructorMap.variant(Haz3lcore.Typ.t) => { + switch (term) { + | SumTerm(name, typs) => Variant(name, [], Some(of_menhir_ast(typs))) + | _ => + raise( + Failure( + "SumTerm expected in constructormap_variant_of_sumterm but not found", + ), + ) }; }; } diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index e32ec52268..298013c94a 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -206,8 +206,12 @@ program: binExp: | e1 = exp; b = binOp; e2 = exp { BinExp (e1, b, e2) } +%inline tupleType: + | OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { TupleType(types) } + + %inline sumTerm: - | i = CONSTRUCTOR_IDENT; OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { SumTerm(i, types) } + | i = CONSTRUCTOR_IDENT; t = tupleType { SumTerm(i, t) } sumTyp: | PLUS; s = sumTerm; { SumTyp(s, None) } %prec SUM_TYP @@ -223,7 +227,7 @@ typ: | STRING_TYPE { StringType } | UNKNOWN; INTERNAL { UnknownType(Internal) } | UNIT { UnitType } - | OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { TupleType(types) } + | t = tupleType { t } | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } | t1 = typ; DASH_ARROW; t2 = typ { ArrowType(t1, t2) } | s = sumTyp; { s } From a01348a873bd0720cc05f5cf019c0d8df3b1ecec Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 2 Dec 2024 10:01:00 -0500 Subject: [PATCH 091/281] Readd comparison with MakeTerm for tests and add basic sum type test --- test/Test_Menhir.re | 41 +++++++++++++++++++++++++++++++++-------- 1 file changed, 33 insertions(+), 8 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 65dbdec840..67e80b23ae 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -39,14 +39,14 @@ let skip_menhir_only_test = (name: string, _exp: Term.Exp.t, _actual: string) => // TODO Assert against result instead of exception for parse failure for better error messages let parser_test = (name: string, exp: Term.Exp.t, actual: string) => - test_case(name, `Quick, () => { - // alco_check("Does not match MakeTerm", exp, make_term_parse(actual)); - menhir_matches( - name, - exp, - actual, - ) - }); + test_case( + name, + `Quick, + () => { + alco_check("Does not match MakeTerm", exp, make_term_parse(actual)); + menhir_matches(name, exp, actual); + }, + ); let menhir_maketerm_equivalent_test = (name: string, actual: string) => test_case(name, `Quick, () => { @@ -417,6 +417,31 @@ let tests = [ |> Exp.fresh, "named_fun f x -> x + 5", ), + parser_test( + "basic sum type", + Let( + Cast( + Var("x") |> Pat.fresh, + Sum([ + Variant("A", [], None), + Variant("B", [], None), + Variant("C", [], Some(Int |> Typ.fresh)), + ]) + |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Pat.fresh, + Ap( + Forward, + Constructor("C", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, + Int(7) |> Exp.fresh, + ) + |> Exp.fresh, + Var("x") |> Exp.fresh, + ) + |> Exp.fresh, + "let x : +A +B +C(Int) = C(7) in x", + ), { // parser_test( // "Partial basic_reference test", From 93251b80b8f4e8bb4fbb6c4e35d0bd961962d14a Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 2 Dec 2024 11:57:43 -0500 Subject: [PATCH 092/281] Update integer and float ops tests and fix some assertion messages --- test/Test_Menhir.re | 50 ++++++++++++++++++++++++++------------------- 1 file changed, 29 insertions(+), 21 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 67e80b23ae..876f780e66 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -19,9 +19,9 @@ let alco_check = exp_typ |> Alcotest.check; let make_term_parse = (s: string) => MakeTerm.from_zip_for_sem(Option.get(Printer.zipper_of_string(s))).term; -let menhir_matches = (name: string, exp: Term.Exp.t, actual: string) => +let menhir_matches = (exp: Term.Exp.t, actual: string) => alco_check( - name ++ " menhir matches expected type", + "menhir matches expected parse", exp, Haz3lmenhir.Conversion.Exp.of_menhir_ast( Haz3lmenhir.Interface.parse_program(actual), @@ -29,7 +29,7 @@ let menhir_matches = (name: string, exp: Term.Exp.t, actual: string) => ); let menhir_only_test = (name: string, exp: Term.Exp.t, actual: string) => - test_case(name, `Quick, () => {menhir_matches(name, exp, actual)}); + test_case(name, `Quick, () => {menhir_matches(exp, actual)}); // TODO Remove these before merge. Using it to mark skipped tests until we fix them. let skip_parser_test = (name: string, _exp: Term.Exp.t, _actual: string) => @@ -43,15 +43,19 @@ let parser_test = (name: string, exp: Term.Exp.t, actual: string) => name, `Quick, () => { - alco_check("Does not match MakeTerm", exp, make_term_parse(actual)); - menhir_matches(name, exp, actual); + alco_check( + "expected parse matches MakeTerm parse", + exp, + make_term_parse(actual), + ); + menhir_matches(exp, actual); }, ); let menhir_maketerm_equivalent_test = (name: string, actual: string) => test_case(name, `Quick, () => { alco_check( - "Does not match MakeTerm", + "Menhir parse matches MakeTerm parse", make_term_parse(actual), Haz3lmenhir.Conversion.Exp.of_menhir_ast( Haz3lmenhir.Interface.parse_program(actual), @@ -332,7 +336,7 @@ let tests = [ |> Exp.fresh, "[1, 2] @ [3, 4]", ), - parser_test( + skip_parser_test( "Integer Ops", BinOp( Int(GreaterThanOrEqual), @@ -345,10 +349,14 @@ let tests = [ ) |> Exp.fresh, BinOp( - Int(Times), - BinOp(Int(Divide), Int(3) |> Exp.fresh, Int(4) |> Exp.fresh) - |> Exp.fresh, - BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) + Int(Divide), + Int(3) |> Exp.fresh, + BinOp( + Int(Times), + Int(4) |> Exp.fresh, + BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) + |> Exp.fresh, + ) |> Exp.fresh, ) |> Exp.fresh, @@ -368,17 +376,17 @@ let tests = [ Float(Minus), Float(2.) |> Exp.fresh, BinOp( - Float(Times), + Float(Divide), + Float(3.) |> Exp.fresh, BinOp( - Float(Divide), - Float(3.) |> Exp.fresh, + Float(Times), Float(4.) |> Exp.fresh, - ) - |> Exp.fresh, - BinOp( - Float(Power), - Float(5.) |> Exp.fresh, - Float(6.) |> Exp.fresh, + BinOp( + Float(Power), + Float(5.) |> Exp.fresh, + Float(6.) |> Exp.fresh, + ) + |> Exp.fresh, ) |> Exp.fresh, ) @@ -474,7 +482,7 @@ let tests = [ test_case("Basic Reference", `Quick, () => { // let _ = Alcotest.skip(); alco_check( - "Does not match MakeTerm", + "Menhir parse does not match MakeTerm", make_term_parse(basic_reference), Haz3lmenhir.Conversion.Exp.of_menhir_ast( Haz3lmenhir.Interface.parse_program(basic_reference), From f202efd08a02133b0492d5fd76624be878d014c6 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 2 Dec 2024 12:03:21 -0500 Subject: [PATCH 093/281] Stop skipping integer ops --- test/Test_Menhir.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 876f780e66..e4cc97e0ab 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -336,7 +336,7 @@ let tests = [ |> Exp.fresh, "[1, 2] @ [3, 4]", ), - skip_parser_test( + parser_test( "Integer Ops", BinOp( Int(GreaterThanOrEqual), From 115d4e2d4ec79a15091075429413823edc902228 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 2 Dec 2024 12:21:43 -0500 Subject: [PATCH 094/281] Fix integer and float precedences --- src/haz3lmenhir/Parser.mly | 7 +++---- test/Test_Menhir.re | 22 ++++++++++++++++++++++ 2 files changed, 25 insertions(+), 4 deletions(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 298013c94a..6f20eebfc8 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -118,9 +118,8 @@ open AST (* Int op precedences *) %left DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL - -%left PLUS MINUS -%left DIVIDE TIMES +%left PLUS MINUS +%right DIVIDE TIMES %right POWER %left GREATER_THAN LESS_THAN @@ -132,7 +131,7 @@ open AST %left DOUBLE_EQUAL_FLOAT NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT %left PLUS_FLOAT MINUS_FLOAT -%left TIMES_FLOAT DIVIDE_FLOAT +%right TIMES_FLOAT DIVIDE_FLOAT %right POWER_FLOAT %left OPEN_CURLY diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index e4cc97e0ab..a0025c3437 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -336,6 +336,28 @@ let tests = [ |> Exp.fresh, "[1, 2] @ [3, 4]", ), + parser_test( + "times and divide precendence", + BinOp( + Int(Times), + Int(1) |> Exp.fresh, + BinOp(Int(Divide), Int(2) |> Exp.fresh, Int(3) |> Exp.fresh) + |> Exp.fresh, + ) + |> Exp.fresh, + "1 * 2 / 3", + ), + parser_test( + "plus and minus precendence", + BinOp( + Int(Plus), + BinOp(Int(Minus), Int(1) |> Exp.fresh, Int(2) |> Exp.fresh) + |> Exp.fresh, + Int(3) |> Exp.fresh, + ) + |> Exp.fresh, + "1 - 2 + 3", + ), parser_test( "Integer Ops", BinOp( From b5ed4c353415e026be325ec6bd9b9dc76e2a1a9a Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 2 Dec 2024 12:45:21 -0500 Subject: [PATCH 095/281] Fixed the menhir sum type parsing & conversion to match hazel sum type parsing --- src/haz3lmenhir/AST.re | 2 +- src/haz3lmenhir/Conversion.re | 21 +- src/haz3lmenhir/Parser.automaton | 7658 ++++++++++++++++++++++++++++++ src/haz3lmenhir/Parser.conflicts | 28 + src/haz3lmenhir/Parser.mly | 3 +- 5 files changed, 7708 insertions(+), 4 deletions(-) create mode 100644 src/haz3lmenhir/Parser.automaton create mode 100644 src/haz3lmenhir/Parser.conflicts diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index ca59e5a815..c2d011a4f4 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -82,7 +82,7 @@ type typ = | BoolType | UnitType | SumTyp(typ, option(typ)) - | SumTerm(string, typ) + | SumTerm(string, option(typ)) | UnknownType(typ_provenance) | TupleType(list(typ)) | ArrayType(typ) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 5924f9c428..43cf64787a 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -265,12 +265,29 @@ and Typ: { } and constructormap_of_sumterm_list = (terms: list(AST.typ)): Haz3lcore.ConstructorMap.t(Haz3lcore.Typ.t) => { - List.map(constructormap_variant_of_sumterm, terms); + List.map(constructormap_variant_of_sumterm, terms) |> List.rev; } and constructormap_variant_of_sumterm = (term: AST.typ): Haz3lcore.ConstructorMap.variant(Haz3lcore.Typ.t) => { switch (term) { - | SumTerm(name, typs) => Variant(name, [], Some(of_menhir_ast(typs))) + | SumTerm(name, typs) => + switch (typs) { + | Some(typs) => + switch (typs) { + | TupleType(ts) => + switch (List.length(ts)) { + | 1 => Variant(name, [], Some(of_menhir_ast(List.hd(ts)))) + | _ => Variant(name, [], Some(of_menhir_ast(typs))) + } + | _ => + raise( + Failure( + "TupleType expected in constructormap_variant_of_sumterm but not found", + ), + ) + } + | None => Variant(name, [], None) + } | _ => raise( Failure( diff --git a/src/haz3lmenhir/Parser.automaton b/src/haz3lmenhir/Parser.automaton new file mode 100644 index 0000000000..b85b68268d --- /dev/null +++ b/src/haz3lmenhir/Parser.automaton @@ -0,0 +1,7658 @@ +State 0: +## Known stack suffix: +## +## LR(1) items: +program' -> . program [ # ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On program shift to state 256 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 257 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 1: +## Known stack suffix: +## WILD +## LR(1) items: +exp -> WILD . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> WILD + +State 2: +## Known stack suffix: +## UNDEF +## LR(1) items: +exp -> UNDEF . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> UNDEF + +State 3: +## Known stack suffix: +## TYP_FUN +## LR(1) items: +exp -> TYP_FUN . tpat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On QUESTION shift to state 4 +-- On IDENT shift to state 7 +-- On CONSTRUCTOR_IDENT shift to state 8 +-- On tpat shift to state 9 +## Reductions: + +State 4: +## Known stack suffix: +## QUESTION +## LR(1) items: +tpat -> QUESTION . TP_TPAT STRING [ SINGLE_EQUAL DASH_ARROW ] +tpat -> QUESTION . [ SINGLE_EQUAL DASH_ARROW ] +## Transitions: +-- On TP_TPAT shift to state 5 +## Reductions: +-- On SINGLE_EQUAL DASH_ARROW +-- reduce production tpat -> QUESTION + +State 5: +## Known stack suffix: +## QUESTION TP_TPAT +## LR(1) items: +tpat -> QUESTION TP_TPAT . STRING [ SINGLE_EQUAL DASH_ARROW ] +## Transitions: +-- On STRING shift to state 6 +## Reductions: + +State 6: +## Known stack suffix: +## QUESTION TP_TPAT STRING +## LR(1) items: +tpat -> QUESTION TP_TPAT STRING . [ SINGLE_EQUAL DASH_ARROW ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL DASH_ARROW +-- reduce production tpat -> QUESTION TP_TPAT STRING + +State 7: +## Known stack suffix: +## IDENT +## LR(1) items: +tpat -> IDENT . [ SINGLE_EQUAL DASH_ARROW ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL DASH_ARROW +-- reduce production tpat -> IDENT + +State 8: +## Known stack suffix: +## CONSTRUCTOR_IDENT +## LR(1) items: +tpat -> CONSTRUCTOR_IDENT . [ SINGLE_EQUAL DASH_ARROW ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL DASH_ARROW +-- reduce production tpat -> CONSTRUCTOR_IDENT + +State 9: +## Known stack suffix: +## TYP_FUN tpat +## LR(1) items: +exp -> TYP_FUN tpat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On DASH_ARROW shift to state 10 +## Reductions: + +State 10: +## Known stack suffix: +## TYP_FUN tpat DASH_ARROW +## LR(1) items: +exp -> TYP_FUN tpat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 255 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 11: +## Known stack suffix: +## TYP +## LR(1) items: +exp -> TYP . tpat SINGLE_EQUAL typ IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On QUESTION shift to state 4 +-- On IDENT shift to state 7 +-- On CONSTRUCTOR_IDENT shift to state 8 +-- On tpat shift to state 12 +## Reductions: + +State 12: +## Known stack suffix: +## TYP tpat +## LR(1) items: +exp -> TYP tpat . SINGLE_EQUAL typ IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SINGLE_EQUAL shift to state 13 +## Reductions: + +State 13: +## Known stack suffix: +## TYP tpat SINGLE_EQUAL +## LR(1) items: +exp -> TYP tpat SINGLE_EQUAL . typ IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 48 +-- On sumTyp shift to state 33 +## Reductions: + +State 14: +## Known stack suffix: +## UNKNOWN +## LR(1) items: +typ -> UNKNOWN . INTERNAL [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On INTERNAL shift to state 15 +## Reductions: + +State 15: +## Known stack suffix: +## UNKNOWN INTERNAL +## LR(1) items: +typ -> UNKNOWN INTERNAL . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production typ -> UNKNOWN INTERNAL + +State 16: +## Known stack suffix: +## UNIT +## LR(1) items: +typ -> UNIT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production typ -> UNIT + +State 17: +## Known stack suffix: +## STRING_TYPE +## LR(1) items: +typ -> STRING_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production typ -> STRING_TYPE + +State 18: +## Known stack suffix: +## QUESTION +## LR(1) items: +typ -> QUESTION . T_TYP STRING [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On T_TYP shift to state 19 +## Reductions: + +State 19: +## Known stack suffix: +## QUESTION T_TYP +## LR(1) items: +typ -> QUESTION T_TYP . STRING [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On STRING shift to state 20 +## Reductions: + +State 20: +## Known stack suffix: +## QUESTION T_TYP STRING +## LR(1) items: +typ -> QUESTION T_TYP STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production typ -> QUESTION T_TYP STRING + +State 21: +## Known stack suffix: +## PLUS +## LR(1) items: +sumTyp -> PLUS . CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS . CONSTRUCTOR_IDENT [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS . CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS . CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS . CONSTRUCTOR_IDENT sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS . CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On CONSTRUCTOR_IDENT shift to state 22 +## Reductions: + +State 22: +## Known stack suffix: +## PLUS CONSTRUCTOR_IDENT +## LR(1) items: +sumTyp -> PLUS CONSTRUCTOR_IDENT . OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS CONSTRUCTOR_IDENT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS CONSTRUCTOR_IDENT . OPEN_PAREN typ CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS CONSTRUCTOR_IDENT . OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS CONSTRUCTOR_IDENT . sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS CONSTRUCTOR_IDENT . OPEN_PAREN typ CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On PLUS shift to state 21 +-- On OPEN_PAREN shift to state 23 +-- On sumTyp shift to state 47 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production sumTyp -> PLUS CONSTRUCTOR_IDENT + +State 23: +## Known stack suffix: +## PLUS CONSTRUCTOR_IDENT OPEN_PAREN +## LR(1) items: +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN . loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN . typ CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN . loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN . typ CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 41 +-- On sumTyp shift to state 33 +-- On separated_nonempty_list(COMMA,typ) shift to state 36 +-- On loption(separated_nonempty_list(COMMA,typ)) shift to state 44 +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,typ)) -> + +State 24: +## Known stack suffix: +## OPEN_SQUARE_BRACKET +## LR(1) items: +typ -> OPEN_SQUARE_BRACKET . typ CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 39 +-- On sumTyp shift to state 33 +## Reductions: + +State 25: +## Known stack suffix: +## OPEN_PAREN +## LR(1) items: +typ -> OPEN_PAREN . loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 30 +-- On sumTyp shift to state 33 +-- On separated_nonempty_list(COMMA,typ) shift to state 36 +-- On loption(separated_nonempty_list(COMMA,typ)) shift to state 37 +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,typ)) -> + +State 26: +## Known stack suffix: +## INT_TYPE +## LR(1) items: +typ -> INT_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production typ -> INT_TYPE + +State 27: +## Known stack suffix: +## FLOAT_TYPE +## LR(1) items: +typ -> FLOAT_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production typ -> FLOAT_TYPE + +State 28: +## Known stack suffix: +## CONSTRUCTOR_IDENT +## LR(1) items: +typ -> CONSTRUCTOR_IDENT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production typ -> CONSTRUCTOR_IDENT + +State 29: +## Known stack suffix: +## BOOL_TYPE +## LR(1) items: +typ -> BOOL_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production typ -> BOOL_TYPE + +State 30: +## Known stack suffix: +## typ +## LR(1) items: +separated_nonempty_list(COMMA,typ) -> typ . [ CLOSE_PAREN ] +separated_nonempty_list(COMMA,typ) -> typ . COMMA separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ DASH_ARROW COMMA CLOSE_PAREN ] +## Transitions: +-- On DASH_ARROW shift to state 31 +-- On COMMA shift to state 34 +## Reductions: +-- On CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,typ) -> typ + +State 31: +## Known stack suffix: +## typ DASH_ARROW +## LR(1) items: +typ -> typ DASH_ARROW . typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 32 +-- On sumTyp shift to state 33 +## Reductions: + +State 32: +## Known stack suffix: +## typ DASH_ARROW typ +## LR(1) items: +typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +typ -> typ DASH_ARROW typ . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production typ -> typ DASH_ARROW typ + +State 33: +## Known stack suffix: +## sumTyp +## LR(1) items: +typ -> sumTyp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production typ -> sumTyp + +State 34: +## Known stack suffix: +## typ COMMA +## LR(1) items: +separated_nonempty_list(COMMA,typ) -> typ COMMA . separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 30 +-- On sumTyp shift to state 33 +-- On separated_nonempty_list(COMMA,typ) shift to state 35 +## Reductions: + +State 35: +## Known stack suffix: +## typ COMMA separated_nonempty_list(COMMA,typ) +## LR(1) items: +separated_nonempty_list(COMMA,typ) -> typ COMMA separated_nonempty_list(COMMA,typ) . [ CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,typ) -> typ COMMA separated_nonempty_list(COMMA,typ) + +State 36: +## Known stack suffix: +## separated_nonempty_list(COMMA,typ) +## LR(1) items: +loption(separated_nonempty_list(COMMA,typ)) -> separated_nonempty_list(COMMA,typ) . [ CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,typ)) -> separated_nonempty_list(COMMA,typ) + +State 37: +## Known stack suffix: +## OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) +## LR(1) items: +typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On CLOSE_PAREN shift to state 38 +## Reductions: + +State 38: +## Known stack suffix: +## OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN +## LR(1) items: +typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN + +State 39: +## Known stack suffix: +## OPEN_SQUARE_BRACKET typ +## LR(1) items: +typ -> OPEN_SQUARE_BRACKET typ . CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ DASH_ARROW CLOSE_SQUARE_BRACKET ] +## Transitions: +-- On DASH_ARROW shift to state 31 +-- On CLOSE_SQUARE_BRACKET shift to state 40 +## Reductions: + +State 40: +## Known stack suffix: +## OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET +## LR(1) items: +typ -> OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production typ -> OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET + +State 41: +## Known stack suffix: +## PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ +## LR(1) items: +separated_nonempty_list(COMMA,typ) -> typ . [ CLOSE_PAREN ] +separated_nonempty_list(COMMA,typ) -> typ . COMMA separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ . CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ DASH_ARROW COMMA CLOSE_PAREN ] +## Transitions: +-- On DASH_ARROW shift to state 31 +-- On COMMA shift to state 34 +-- On CLOSE_PAREN shift to state 42 +## Reductions: +-- On CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,typ) -> typ +** Conflict on CLOSE_PAREN + +State 42: +## Known stack suffix: +## PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN +## LR(1) items: +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN . sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On PLUS shift to state 21 +-- On sumTyp shift to state 43 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN + +State 43: +## Known stack suffix: +## PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN sumTyp +## LR(1) items: +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN sumTyp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN sumTyp + +State 44: +## Known stack suffix: +## PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) +## LR(1) items: +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) . CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On CLOSE_PAREN shift to state 45 +## Reductions: + +State 45: +## Known stack suffix: +## PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN +## LR(1) items: +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN . sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +-- On PLUS shift to state 21 +-- On sumTyp shift to state 46 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN + +State 46: +## Known stack suffix: +## PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN sumTyp +## LR(1) items: +sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN sumTyp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN sumTyp + +State 47: +## Known stack suffix: +## PLUS CONSTRUCTOR_IDENT sumTyp +## LR(1) items: +sumTyp -> PLUS CONSTRUCTOR_IDENT sumTyp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL +-- reduce production sumTyp -> PLUS CONSTRUCTOR_IDENT sumTyp + +State 48: +## Known stack suffix: +## TYP tpat SINGLE_EQUAL typ +## LR(1) items: +exp -> TYP tpat SINGLE_EQUAL typ . IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ IN DASH_ARROW ] +## Transitions: +-- On IN shift to state 49 +-- On DASH_ARROW shift to state 31 +## Reductions: + +State 49: +## Known stack suffix: +## TYP tpat SINGLE_EQUAL typ IN +## LR(1) items: +exp -> TYP tpat SINGLE_EQUAL typ IN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 254 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 50: +## Known stack suffix: +## TRUE +## LR(1) items: +exp -> TRUE . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> TRUE + +State 51: +## Known stack suffix: +## TEST +## LR(1) items: +exp -> TEST . exp END [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 252 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 52: +## Known stack suffix: +## STRING +## LR(1) items: +exp -> STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> STRING + +State 53: +## Known stack suffix: +## QUESTION +## LR(1) items: +exp -> QUESTION . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> QUESTION . E_EXP STRING [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On E_EXP shift to state 54 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> QUESTION + +State 54: +## Known stack suffix: +## QUESTION E_EXP +## LR(1) items: +exp -> QUESTION E_EXP . STRING [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING shift to state 55 +## Reductions: + +State 55: +## Known stack suffix: +## QUESTION E_EXP STRING +## LR(1) items: +exp -> QUESTION E_EXP STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> QUESTION E_EXP STRING + +State 56: +## Known stack suffix: +## PAUSE +## LR(1) items: +filterAction -> PAUSE . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] +## Transitions: +## Reductions: +-- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN +-- reduce production filterAction -> PAUSE + +State 57: +## Known stack suffix: +## OPEN_SQUARE_BRACKET +## LR(1) items: +exp -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On separated_nonempty_list(COMMA,exp) shift to state 243 +-- On loption(separated_nonempty_list(COMMA,exp)) shift to state 250 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 246 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: +-- On CLOSE_SQUARE_BRACKET +-- reduce production loption(separated_nonempty_list(COMMA,exp)) -> + +State 58: +## Known stack suffix: +## OPEN_PAREN +## LR(1) items: +exp -> OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> OPEN_PAREN . exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 241 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 59: +## Known stack suffix: +## NAMED_FUN +## LR(1) items: +funExp -> NAMED_FUN . IDENT pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On IDENT shift to state 60 +## Reductions: + +State 60: +## Known stack suffix: +## NAMED_FUN IDENT +## LR(1) items: +funExp -> NAMED_FUN IDENT . pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 61 +-- On TRUE shift to state 62 +-- On STRING shift to state 63 +-- On QUESTION shift to state 64 +-- On OPEN_SQUARE_BRACKET shift to state 67 +-- On OPEN_PAREN shift to state 68 +-- On INT shift to state 69 +-- On IDENT shift to state 70 +-- On FLOAT shift to state 71 +-- On FALSE shift to state 72 +-- On CONSTRUCTOR_IDENT shift to state 73 +-- On pat shift to state 99 +## Reductions: + +State 61: +## Known stack suffix: +## WILD +## LR(1) items: +pat -> WILD . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> WILD + +State 62: +## Known stack suffix: +## TRUE +## LR(1) items: +pat -> TRUE . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> TRUE + +State 63: +## Known stack suffix: +## STRING +## LR(1) items: +pat -> STRING . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> STRING + +State 64: +## Known stack suffix: +## QUESTION +## LR(1) items: +pat -> QUESTION . P_PAT STRING [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> QUESTION . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On P_PAT shift to state 65 +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> QUESTION + +State 65: +## Known stack suffix: +## QUESTION P_PAT +## LR(1) items: +pat -> QUESTION P_PAT . STRING [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On STRING shift to state 66 +## Reductions: + +State 66: +## Known stack suffix: +## QUESTION P_PAT STRING +## LR(1) items: +pat -> QUESTION P_PAT STRING . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> QUESTION P_PAT STRING + +State 67: +## Known stack suffix: +## OPEN_SQUARE_BRACKET +## LR(1) items: +pat -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 61 +-- On TRUE shift to state 62 +-- On STRING shift to state 63 +-- On QUESTION shift to state 64 +-- On OPEN_SQUARE_BRACKET shift to state 67 +-- On OPEN_PAREN shift to state 68 +-- On INT shift to state 69 +-- On IDENT shift to state 70 +-- On FLOAT shift to state 71 +-- On FALSE shift to state 72 +-- On CONSTRUCTOR_IDENT shift to state 73 +-- On separated_nonempty_list(COMMA,pat) shift to state 90 +-- On pat shift to state 91 +-- On loption(separated_nonempty_list(COMMA,pat)) shift to state 97 +## Reductions: +-- On CLOSE_SQUARE_BRACKET +-- reduce production loption(separated_nonempty_list(COMMA,pat)) -> + +State 68: +## Known stack suffix: +## OPEN_PAREN +## LR(1) items: +pat -> OPEN_PAREN . pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> OPEN_PAREN . pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 61 +-- On TRUE shift to state 62 +-- On STRING shift to state 63 +-- On QUESTION shift to state 64 +-- On OPEN_SQUARE_BRACKET shift to state 67 +-- On OPEN_PAREN shift to state 68 +-- On INT shift to state 69 +-- On IDENT shift to state 70 +-- On FLOAT shift to state 71 +-- On FALSE shift to state 72 +-- On CONSTRUCTOR_IDENT shift to state 73 +-- On pat shift to state 76 +## Reductions: + +State 69: +## Known stack suffix: +## INT +## LR(1) items: +pat -> INT . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> INT + +State 70: +## Known stack suffix: +## IDENT +## LR(1) items: +pat -> IDENT . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> IDENT + +State 71: +## Known stack suffix: +## FLOAT +## LR(1) items: +pat -> FLOAT . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> FLOAT + +State 72: +## Known stack suffix: +## FALSE +## LR(1) items: +pat -> FALSE . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> FALSE + +State 73: +## Known stack suffix: +## CONSTRUCTOR_IDENT +## LR(1) items: +pat -> CONSTRUCTOR_IDENT . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> CONSTRUCTOR_IDENT . TILDE typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On TILDE shift to state 74 +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> CONSTRUCTOR_IDENT + +State 74: +## Known stack suffix: +## CONSTRUCTOR_IDENT TILDE +## LR(1) items: +pat -> CONSTRUCTOR_IDENT TILDE . typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 75 +-- On sumTyp shift to state 33 +## Reductions: + +State 75: +## Known stack suffix: +## CONSTRUCTOR_IDENT TILDE typ +## LR(1) items: +pat -> CONSTRUCTOR_IDENT TILDE typ . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> CONSTRUCTOR_IDENT TILDE typ + +State 76: +## Known stack suffix: +## OPEN_PAREN pat +## LR(1) items: +pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_PAREN ] +pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_PAREN ] +pat -> OPEN_PAREN pat . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> OPEN_PAREN pat . COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_PAREN ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_PAREN ] +## Transitions: +-- On OPEN_PAREN shift to state 77 +-- On OPEN_CURLY shift to state 79 +-- On CONS shift to state 84 +-- On COMMA shift to state 89 +-- On COLON shift to state 86 +-- On CLOSE_PAREN shift to state 96 +## Reductions: + +State 77: +## Known stack suffix: +## pat OPEN_PAREN +## LR(1) items: +pat -> pat OPEN_PAREN . pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 61 +-- On TRUE shift to state 62 +-- On STRING shift to state 63 +-- On QUESTION shift to state 64 +-- On OPEN_SQUARE_BRACKET shift to state 67 +-- On OPEN_PAREN shift to state 68 +-- On INT shift to state 69 +-- On IDENT shift to state 70 +-- On FLOAT shift to state 71 +-- On FALSE shift to state 72 +-- On CONSTRUCTOR_IDENT shift to state 73 +-- On pat shift to state 78 +## Reductions: + +State 78: +## Known stack suffix: +## pat OPEN_PAREN pat +## LR(1) items: +pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY CONS COLON CLOSE_PAREN ] +pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY CONS COLON CLOSE_PAREN ] +pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY CONS COLON CLOSE_PAREN ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY CONS COLON CLOSE_PAREN ] +pat -> pat OPEN_PAREN pat . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On OPEN_PAREN shift to state 77 +-- On OPEN_CURLY shift to state 79 +-- On CONS shift to state 84 +-- On COLON shift to state 86 +-- On CLOSE_PAREN shift to state 88 +## Reductions: + +State 79: +## Known stack suffix: +## pat OPEN_CURLY +## LR(1) items: +pat -> pat OPEN_CURLY . typ EQUAL_ARROW typ CLOSE_CURLY [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 80 +-- On sumTyp shift to state 33 +## Reductions: + +State 80: +## Known stack suffix: +## pat OPEN_CURLY typ +## LR(1) items: +pat -> pat OPEN_CURLY typ . EQUAL_ARROW typ CLOSE_CURLY [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] +## Transitions: +-- On EQUAL_ARROW shift to state 81 +-- On DASH_ARROW shift to state 31 +## Reductions: + +State 81: +## Known stack suffix: +## pat OPEN_CURLY typ EQUAL_ARROW +## LR(1) items: +pat -> pat OPEN_CURLY typ EQUAL_ARROW . typ CLOSE_CURLY [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 82 +-- On sumTyp shift to state 33 +## Reductions: + +State 82: +## Known stack suffix: +## pat OPEN_CURLY typ EQUAL_ARROW typ +## LR(1) items: +pat -> pat OPEN_CURLY typ EQUAL_ARROW typ . CLOSE_CURLY [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ DASH_ARROW CLOSE_CURLY ] +## Transitions: +-- On DASH_ARROW shift to state 31 +-- On CLOSE_CURLY shift to state 83 +## Reductions: + +State 83: +## Known stack suffix: +## pat OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY +## LR(1) items: +pat -> pat OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> pat OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY + +State 84: +## Known stack suffix: +## pat CONS +## LR(1) items: +pat -> pat CONS . pat [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 61 +-- On TRUE shift to state 62 +-- On STRING shift to state 63 +-- On QUESTION shift to state 64 +-- On OPEN_SQUARE_BRACKET shift to state 67 +-- On OPEN_PAREN shift to state 68 +-- On INT shift to state 69 +-- On IDENT shift to state 70 +-- On FLOAT shift to state 71 +-- On FALSE shift to state 72 +-- On CONSTRUCTOR_IDENT shift to state 73 +-- On pat shift to state 85 +## Reductions: + +State 85: +## Known stack suffix: +## pat CONS pat +## LR(1) items: +pat -> pat . COLON typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . CONS pat [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat CONS pat . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On OPEN_PAREN shift to state 77 +## Reductions: +-- On SINGLE_EQUAL OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> pat CONS pat + +State 86: +## Known stack suffix: +## pat COLON +## LR(1) items: +pat -> pat COLON . typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 87 +-- On sumTyp shift to state 33 +## Reductions: + +State 87: +## Known stack suffix: +## pat COLON typ +## LR(1) items: +pat -> pat COLON typ . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +typ -> typ . DASH_ARROW typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On DASH_ARROW shift to state 31 +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> pat COLON typ + +State 88: +## Known stack suffix: +## pat OPEN_PAREN pat CLOSE_PAREN +## LR(1) items: +pat -> pat OPEN_PAREN pat CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> pat OPEN_PAREN pat CLOSE_PAREN + +State 89: +## Known stack suffix: +## OPEN_PAREN pat COMMA +## LR(1) items: +pat -> OPEN_PAREN pat COMMA . loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 61 +-- On TRUE shift to state 62 +-- On STRING shift to state 63 +-- On QUESTION shift to state 64 +-- On OPEN_SQUARE_BRACKET shift to state 67 +-- On OPEN_PAREN shift to state 68 +-- On INT shift to state 69 +-- On IDENT shift to state 70 +-- On FLOAT shift to state 71 +-- On FALSE shift to state 72 +-- On CONSTRUCTOR_IDENT shift to state 73 +-- On separated_nonempty_list(COMMA,pat) shift to state 90 +-- On pat shift to state 91 +-- On loption(separated_nonempty_list(COMMA,pat)) shift to state 94 +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,pat)) -> + +State 90: +## Known stack suffix: +## separated_nonempty_list(COMMA,pat) +## LR(1) items: +loption(separated_nonempty_list(COMMA,pat)) -> separated_nonempty_list(COMMA,pat) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,pat)) -> separated_nonempty_list(COMMA,pat) + +State 91: +## Known stack suffix: +## pat +## LR(1) items: +pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +separated_nonempty_list(COMMA,pat) -> pat . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +separated_nonempty_list(COMMA,pat) -> pat . COMMA separated_nonempty_list(COMMA,pat) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On OPEN_PAREN shift to state 77 +-- On OPEN_CURLY shift to state 79 +-- On CONS shift to state 84 +-- On COMMA shift to state 92 +-- On COLON shift to state 86 +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,pat) -> pat + +State 92: +## Known stack suffix: +## pat COMMA +## LR(1) items: +separated_nonempty_list(COMMA,pat) -> pat COMMA . separated_nonempty_list(COMMA,pat) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 61 +-- On TRUE shift to state 62 +-- On STRING shift to state 63 +-- On QUESTION shift to state 64 +-- On OPEN_SQUARE_BRACKET shift to state 67 +-- On OPEN_PAREN shift to state 68 +-- On INT shift to state 69 +-- On IDENT shift to state 70 +-- On FLOAT shift to state 71 +-- On FALSE shift to state 72 +-- On CONSTRUCTOR_IDENT shift to state 73 +-- On separated_nonempty_list(COMMA,pat) shift to state 93 +-- On pat shift to state 91 +## Reductions: + +State 93: +## Known stack suffix: +## pat COMMA separated_nonempty_list(COMMA,pat) +## LR(1) items: +separated_nonempty_list(COMMA,pat) -> pat COMMA separated_nonempty_list(COMMA,pat) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,pat) -> pat COMMA separated_nonempty_list(COMMA,pat) + +State 94: +## Known stack suffix: +## OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) +## LR(1) items: +pat -> OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On CLOSE_PAREN shift to state 95 +## Reductions: + +State 95: +## Known stack suffix: +## OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN +## LR(1) items: +pat -> OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN + +State 96: +## Known stack suffix: +## OPEN_PAREN pat CLOSE_PAREN +## LR(1) items: +pat -> OPEN_PAREN pat CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> OPEN_PAREN pat CLOSE_PAREN + +State 97: +## Known stack suffix: +## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) +## LR(1) items: +pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) . CLOSE_SQUARE_BRACKET [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On CLOSE_SQUARE_BRACKET shift to state 98 +## Reductions: + +State 98: +## Known stack suffix: +## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET +## LR(1) items: +pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET + +State 99: +## Known stack suffix: +## NAMED_FUN IDENT pat +## LR(1) items: +funExp -> NAMED_FUN IDENT pat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] +pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] +pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] +## Transitions: +-- On OPEN_PAREN shift to state 77 +-- On OPEN_CURLY shift to state 79 +-- On DASH_ARROW shift to state 100 +-- On CONS shift to state 84 +-- On COLON shift to state 86 +## Reductions: + +State 100: +## Known stack suffix: +## NAMED_FUN IDENT pat DASH_ARROW +## LR(1) items: +funExp -> NAMED_FUN IDENT pat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 240 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 101: +## Known stack suffix: +## MINUS +## LR(1) items: +unExp -> MINUS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 239 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 102: +## Known stack suffix: +## L_NOT +## LR(1) items: +unExp -> L_NOT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 238 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 103: +## Known stack suffix: +## LET +## LR(1) items: +exp -> LET . pat SINGLE_EQUAL exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 61 +-- On TRUE shift to state 62 +-- On STRING shift to state 63 +-- On QUESTION shift to state 64 +-- On OPEN_SQUARE_BRACKET shift to state 67 +-- On OPEN_PAREN shift to state 68 +-- On INT shift to state 69 +-- On IDENT shift to state 70 +-- On FLOAT shift to state 71 +-- On FALSE shift to state 72 +-- On CONSTRUCTOR_IDENT shift to state 73 +-- On pat shift to state 104 +## Reductions: + +State 104: +## Known stack suffix: +## LET pat +## LR(1) items: +exp -> LET pat . SINGLE_EQUAL exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +pat -> pat . COLON typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY CONS COLON ] +pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY CONS COLON ] +pat -> pat . CONS pat [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY CONS COLON ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY CONS COLON ] +## Transitions: +-- On SINGLE_EQUAL shift to state 105 +-- On OPEN_PAREN shift to state 77 +-- On OPEN_CURLY shift to state 79 +-- On CONS shift to state 84 +-- On COLON shift to state 86 +## Reductions: + +State 105: +## Known stack suffix: +## LET pat SINGLE_EQUAL +## LR(1) items: +exp -> LET pat SINGLE_EQUAL . exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 235 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 106: +## Known stack suffix: +## LESS_THAN +## LR(1) items: +exp -> LESS_THAN . LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On LESS_THAN shift to state 107 +## Reductions: + +State 107: +## Known stack suffix: +## LESS_THAN LESS_THAN +## LR(1) items: +exp -> LESS_THAN LESS_THAN . exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 230 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 108: +## Known stack suffix: +## INT +## LR(1) items: +exp -> INT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> INT + +State 109: +## Known stack suffix: +## IF +## LR(1) items: +exp -> IF . exp THEN exp ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 225 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 110: +## Known stack suffix: +## IDENT +## LR(1) items: +exp -> IDENT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> IDENT + +State 111: +## Known stack suffix: +## HIDE +## LR(1) items: +filterAction -> HIDE . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] +## Transitions: +## Reductions: +-- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN +-- reduce production filterAction -> HIDE + +State 112: +## Known stack suffix: +## FUN +## LR(1) items: +funExp -> FUN . pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 61 +-- On TRUE shift to state 62 +-- On STRING shift to state 63 +-- On QUESTION shift to state 64 +-- On OPEN_SQUARE_BRACKET shift to state 67 +-- On OPEN_PAREN shift to state 68 +-- On INT shift to state 69 +-- On IDENT shift to state 70 +-- On FLOAT shift to state 71 +-- On FALSE shift to state 72 +-- On CONSTRUCTOR_IDENT shift to state 73 +-- On pat shift to state 113 +## Reductions: + +State 113: +## Known stack suffix: +## FUN pat +## LR(1) items: +funExp -> FUN pat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] +pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] +pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] +## Transitions: +-- On OPEN_PAREN shift to state 77 +-- On OPEN_CURLY shift to state 79 +-- On DASH_ARROW shift to state 114 +-- On CONS shift to state 84 +-- On COLON shift to state 86 +## Reductions: + +State 114: +## Known stack suffix: +## FUN pat DASH_ARROW +## LR(1) items: +funExp -> FUN pat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 224 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 115: +## Known stack suffix: +## FLOAT +## LR(1) items: +exp -> FLOAT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> FLOAT + +State 116: +## Known stack suffix: +## FIX +## LR(1) items: +exp -> FIX . pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 61 +-- On TRUE shift to state 62 +-- On STRING shift to state 63 +-- On QUESTION shift to state 64 +-- On OPEN_SQUARE_BRACKET shift to state 67 +-- On OPEN_PAREN shift to state 68 +-- On INT shift to state 69 +-- On IDENT shift to state 70 +-- On FLOAT shift to state 71 +-- On FALSE shift to state 72 +-- On CONSTRUCTOR_IDENT shift to state 73 +-- On pat shift to state 117 +## Reductions: + +State 117: +## Known stack suffix: +## FIX pat +## LR(1) items: +exp -> FIX pat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] +pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] +pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] +## Transitions: +-- On OPEN_PAREN shift to state 77 +-- On OPEN_CURLY shift to state 79 +-- On DASH_ARROW shift to state 118 +-- On CONS shift to state 84 +-- On COLON shift to state 86 +## Reductions: + +State 118: +## Known stack suffix: +## FIX pat DASH_ARROW +## LR(1) items: +exp -> FIX pat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 223 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 119: +## Known stack suffix: +## FALSE +## LR(1) items: +exp -> FALSE . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> FALSE + +State 120: +## Known stack suffix: +## EVAL +## LR(1) items: +filterAction -> EVAL . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] +## Transitions: +## Reductions: +-- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN +-- reduce production filterAction -> EVAL + +State 121: +## Known stack suffix: +## DOLLAR_SIGN +## LR(1) items: +unExp -> DOLLAR_SIGN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 222 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 122: +## Known stack suffix: +## DEBUG +## LR(1) items: +filterAction -> DEBUG . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] +## Transitions: +## Reductions: +-- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN +-- reduce production filterAction -> DEBUG + +State 123: +## Known stack suffix: +## CONSTRUCTOR_IDENT +## LR(1) items: +exp -> CONSTRUCTOR_IDENT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> CONSTRUCTOR_IDENT . TILDE typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> CONSTRUCTOR_IDENT . COLON typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TILDE shift to state 124 +-- On COLON shift to state 126 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> CONSTRUCTOR_IDENT + +State 124: +## Known stack suffix: +## CONSTRUCTOR_IDENT TILDE +## LR(1) items: +exp -> CONSTRUCTOR_IDENT TILDE . typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 125 +-- On sumTyp shift to state 33 +## Reductions: + +State 125: +## Known stack suffix: +## CONSTRUCTOR_IDENT TILDE typ +## LR(1) items: +exp -> CONSTRUCTOR_IDENT TILDE typ . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On DASH_ARROW shift to state 31 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> CONSTRUCTOR_IDENT TILDE typ + +State 126: +## Known stack suffix: +## CONSTRUCTOR_IDENT COLON +## LR(1) items: +exp -> CONSTRUCTOR_IDENT COLON . typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 127 +-- On sumTyp shift to state 33 +## Reductions: + +State 127: +## Known stack suffix: +## CONSTRUCTOR_IDENT COLON typ +## LR(1) items: +exp -> CONSTRUCTOR_IDENT COLON typ . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On DASH_ARROW shift to state 31 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> CONSTRUCTOR_IDENT COLON typ + +State 128: +## Known stack suffix: +## CASE +## LR(1) items: +case -> CASE . exp list(rul) END [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 213 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 129: +## Known stack suffix: +## BUILTIN +## LR(1) items: +exp -> BUILTIN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> BUILTIN + +State 130: +## Known stack suffix: +## unExp +## LR(1) items: +exp -> unExp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> unExp + +State 131: +## Known stack suffix: +## funExp +## LR(1) items: +exp -> funExp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> funExp + +State 132: +## Known stack suffix: +## filterAction +## LR(1) items: +exp -> filterAction . exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 133 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 133: +## Known stack suffix: +## filterAction exp +## LR(1) items: +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> filterAction exp . IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On IN shift to state 211 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: + +State 134: +## Known stack suffix: +## exp TIMES_FLOAT +## LR(1) items: +binExp -> exp TIMES_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 135 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 135: +## Known stack suffix: +## exp TIMES_FLOAT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp TIMES_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp TIMES_FLOAT exp + +State 136: +## Known stack suffix: +## exp STRING_EQUAL +## LR(1) items: +binExp -> exp STRING_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 137 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 137: +## Known stack suffix: +## exp STRING_EQUAL exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp STRING_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production binExp -> exp STRING_EQUAL exp + +State 138: +## Known stack suffix: +## case +## LR(1) items: +exp -> case . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> case + +State 139: +## Known stack suffix: +## binExp +## LR(1) items: +exp -> binExp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> binExp + +State 140: +## Known stack suffix: +## exp STRING_CONCAT +## LR(1) items: +binExp -> exp STRING_CONCAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 141 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 141: +## Known stack suffix: +## exp STRING_CONCAT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp STRING_CONCAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production binExp -> exp STRING_CONCAT exp + +State 142: +## Known stack suffix: +## exp SEMI_COLON +## LR(1) items: +exp -> exp SEMI_COLON . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 143 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 143: +## Known stack suffix: +## exp SEMI_COLON exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp SEMI_COLON exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> exp SEMI_COLON exp + +State 144: +## Known stack suffix: +## exp L_OR +## LR(1) items: +binExp -> exp L_OR . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 145 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 145: +## Known stack suffix: +## exp L_OR exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp L_OR exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production binExp -> exp L_OR exp + +State 146: +## Known stack suffix: +## exp L_AND +## LR(1) items: +binExp -> exp L_AND . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 147 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 147: +## Known stack suffix: +## exp L_AND exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp L_AND exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production binExp -> exp L_AND exp + +State 148: +## Known stack suffix: +## exp QUESTION +## LR(1) items: +exp -> exp QUESTION . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On OPEN_CURLY shift to state 149 +## Reductions: + +State 149: +## Known stack suffix: +## exp QUESTION OPEN_CURLY +## LR(1) items: +exp -> exp QUESTION OPEN_CURLY . typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 150 +-- On sumTyp shift to state 33 +## Reductions: + +State 150: +## Known stack suffix: +## exp QUESTION OPEN_CURLY typ +## LR(1) items: +exp -> exp QUESTION OPEN_CURLY typ . EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] +## Transitions: +-- On EQUAL_ARROW shift to state 151 +-- On DASH_ARROW shift to state 31 +## Reductions: + +State 151: +## Known stack suffix: +## exp QUESTION OPEN_CURLY typ EQUAL_ARROW +## LR(1) items: +exp -> exp QUESTION OPEN_CURLY typ EQUAL_ARROW . typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 152 +-- On sumTyp shift to state 33 +## Reductions: + +State 152: +## Known stack suffix: +## exp QUESTION OPEN_CURLY typ EQUAL_ARROW typ +## LR(1) items: +exp -> exp QUESTION OPEN_CURLY typ EQUAL_ARROW typ . CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ DASH_ARROW CLOSE_CURLY ] +## Transitions: +-- On DASH_ARROW shift to state 31 +-- On CLOSE_CURLY shift to state 153 +## Reductions: + +State 153: +## Known stack suffix: +## exp QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY +## LR(1) items: +exp -> exp QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> exp QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY + +State 154: +## Known stack suffix: +## exp POWER_FLOAT +## LR(1) items: +binExp -> exp POWER_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 155 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 155: +## Known stack suffix: +## exp POWER_FLOAT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp POWER_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp POWER_FLOAT exp + +State 156: +## Known stack suffix: +## exp OPEN_PAREN +## LR(1) items: +exp -> exp OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 157 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 157: +## Known stack suffix: +## exp OPEN_PAREN exp +## LR(1) items: +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp OPEN_PAREN exp . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On CLOSE_PAREN shift to state 210 +-- On AT_SYMBOL shift to state 173 +## Reductions: + +State 158: +## Known stack suffix: +## exp TIMES +## LR(1) items: +binExp -> exp TIMES . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 159 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 159: +## Known stack suffix: +## exp TIMES exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp TIMES exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp TIMES exp + +State 160: +## Known stack suffix: +## exp POWER +## LR(1) items: +binExp -> exp POWER . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 161 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 161: +## Known stack suffix: +## exp POWER exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp POWER exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp POWER exp + +State 162: +## Known stack suffix: +## exp PLUS_FLOAT +## LR(1) items: +binExp -> exp PLUS_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 163 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 163: +## Known stack suffix: +## exp PLUS_FLOAT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp PLUS_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp PLUS_FLOAT exp + +State 164: +## Known stack suffix: +## exp OPEN_CURLY +## LR(1) items: +exp -> exp OPEN_CURLY . typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 165 +-- On sumTyp shift to state 33 +## Reductions: + +State 165: +## Known stack suffix: +## exp OPEN_CURLY typ +## LR(1) items: +exp -> exp OPEN_CURLY typ . EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] +## Transitions: +-- On EQUAL_ARROW shift to state 166 +-- On DASH_ARROW shift to state 31 +## Reductions: + +State 166: +## Known stack suffix: +## exp OPEN_CURLY typ EQUAL_ARROW +## LR(1) items: +exp -> exp OPEN_CURLY typ EQUAL_ARROW . typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 167 +-- On sumTyp shift to state 33 +## Reductions: + +State 167: +## Known stack suffix: +## exp OPEN_CURLY typ EQUAL_ARROW typ +## LR(1) items: +exp -> exp OPEN_CURLY typ EQUAL_ARROW typ . CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ DASH_ARROW CLOSE_CURLY ] +## Transitions: +-- On DASH_ARROW shift to state 31 +-- On CLOSE_CURLY shift to state 168 +## Reductions: + +State 168: +## Known stack suffix: +## exp OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY +## LR(1) items: +exp -> exp OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> exp OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY + +State 169: +## Known stack suffix: +## exp DIVIDE_FLOAT +## LR(1) items: +binExp -> exp DIVIDE_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 170 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 170: +## Known stack suffix: +## exp DIVIDE_FLOAT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp DIVIDE_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp DIVIDE_FLOAT exp + +State 171: +## Known stack suffix: +## exp CONS +## LR(1) items: +exp -> exp CONS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 172 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 172: +## Known stack suffix: +## exp CONS exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp CONS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On OPEN_PAREN shift to state 156 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> exp CONS exp + +State 173: +## Known stack suffix: +## exp AT_SYMBOL +## LR(1) items: +exp -> exp AT_SYMBOL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp AT_SYMBOL . LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 174 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 177 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 174: +## Known stack suffix: +## exp AT_SYMBOL LESS_THAN +## LR(1) items: +exp -> exp AT_SYMBOL LESS_THAN . typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> LESS_THAN . LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On UNKNOWN shift to state 14 +-- On UNIT shift to state 16 +-- On STRING_TYPE shift to state 17 +-- On QUESTION shift to state 18 +-- On PLUS shift to state 21 +-- On OPEN_SQUARE_BRACKET shift to state 24 +-- On OPEN_PAREN shift to state 25 +-- On LESS_THAN shift to state 107 +-- On INT_TYPE shift to state 26 +-- On FLOAT_TYPE shift to state 27 +-- On CONSTRUCTOR_IDENT shift to state 28 +-- On BOOL_TYPE shift to state 29 +-- On typ shift to state 175 +-- On sumTyp shift to state 33 +## Reductions: + +State 175: +## Known stack suffix: +## exp AT_SYMBOL LESS_THAN typ +## LR(1) items: +exp -> exp AT_SYMBOL LESS_THAN typ . GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +typ -> typ . DASH_ARROW typ [ GREATER_THAN DASH_ARROW ] +## Transitions: +-- On GREATER_THAN shift to state 176 +-- On DASH_ARROW shift to state 31 +## Reductions: + +State 176: +## Known stack suffix: +## exp AT_SYMBOL LESS_THAN typ GREATER_THAN +## LR(1) items: +exp -> exp AT_SYMBOL LESS_THAN typ GREATER_THAN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> exp AT_SYMBOL LESS_THAN typ GREATER_THAN + +State 177: +## Known stack suffix: +## exp AT_SYMBOL exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp AT_SYMBOL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> exp AT_SYMBOL exp + +State 178: +## Known stack suffix: +## exp NOT_EQUAL_FLOAT +## LR(1) items: +binExp -> exp NOT_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 179 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 179: +## Known stack suffix: +## exp NOT_EQUAL_FLOAT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp NOT_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp NOT_EQUAL_FLOAT exp + +State 180: +## Known stack suffix: +## exp MINUS_FLOAT +## LR(1) items: +binExp -> exp MINUS_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 181 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 181: +## Known stack suffix: +## exp MINUS_FLOAT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp MINUS_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp MINUS_FLOAT exp + +State 182: +## Known stack suffix: +## exp LESS_THAN_FLOAT +## LR(1) items: +binExp -> exp LESS_THAN_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 183 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 183: +## Known stack suffix: +## exp LESS_THAN_FLOAT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp LESS_THAN_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp LESS_THAN_FLOAT exp + +State 184: +## Known stack suffix: +## exp LESS_THAN_EQUAL_FLOAT +## LR(1) items: +binExp -> exp LESS_THAN_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 185 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 185: +## Known stack suffix: +## exp LESS_THAN_EQUAL_FLOAT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp LESS_THAN_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp LESS_THAN_EQUAL_FLOAT exp + +State 186: +## Known stack suffix: +## exp LESS_THAN +## LR(1) items: +binExp -> exp LESS_THAN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 187 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 187: +## Known stack suffix: +## exp LESS_THAN exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp LESS_THAN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp LESS_THAN exp + +State 188: +## Known stack suffix: +## exp GREATER_THAN_FLOAT +## LR(1) items: +binExp -> exp GREATER_THAN_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 189 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 189: +## Known stack suffix: +## exp GREATER_THAN_FLOAT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp GREATER_THAN_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp GREATER_THAN_FLOAT exp + +State 190: +## Known stack suffix: +## exp GREATER_THAN_EQUAL_FLOAT +## LR(1) items: +binExp -> exp GREATER_THAN_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 191 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 191: +## Known stack suffix: +## exp GREATER_THAN_EQUAL_FLOAT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp GREATER_THAN_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp GREATER_THAN_EQUAL_FLOAT exp + +State 192: +## Known stack suffix: +## exp DOUBLE_EQUAL_FLOAT +## LR(1) items: +binExp -> exp DOUBLE_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 193 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 193: +## Known stack suffix: +## exp DOUBLE_EQUAL_FLOAT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp DOUBLE_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp DOUBLE_EQUAL_FLOAT exp + +State 194: +## Known stack suffix: +## exp GREATER_THAN +## LR(1) items: +binExp -> exp GREATER_THAN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 195 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 195: +## Known stack suffix: +## exp GREATER_THAN exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp GREATER_THAN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DIVIDE_FLOAT shift to state 169 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp GREATER_THAN exp + +State 196: +## Known stack suffix: +## exp DIVIDE +## LR(1) items: +binExp -> exp DIVIDE . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 197 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 197: +## Known stack suffix: +## exp DIVIDE exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp DIVIDE exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp DIVIDE exp + +State 198: +## Known stack suffix: +## exp PLUS +## LR(1) items: +binExp -> exp PLUS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 199 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 199: +## Known stack suffix: +## exp PLUS exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp PLUS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp PLUS exp + +State 200: +## Known stack suffix: +## exp NOT_EQUAL +## LR(1) items: +binExp -> exp NOT_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 201 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 201: +## Known stack suffix: +## exp NOT_EQUAL exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp NOT_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN NOT_EQUAL LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp NOT_EQUAL exp + +State 202: +## Known stack suffix: +## exp MINUS +## LR(1) items: +binExp -> exp MINUS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 203 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 203: +## Known stack suffix: +## exp MINUS exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp MINUS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp MINUS exp + +State 204: +## Known stack suffix: +## exp LESS_THAN_EQUAL +## LR(1) items: +binExp -> exp LESS_THAN_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 205 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 205: +## Known stack suffix: +## exp LESS_THAN_EQUAL exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp LESS_THAN_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN NOT_EQUAL LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp LESS_THAN_EQUAL exp + +State 206: +## Known stack suffix: +## exp GREATER_THAN_EQUAL +## LR(1) items: +binExp -> exp GREATER_THAN_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 207 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 207: +## Known stack suffix: +## exp GREATER_THAN_EQUAL exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp GREATER_THAN_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN NOT_EQUAL LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp GREATER_THAN_EQUAL exp + +State 208: +## Known stack suffix: +## exp DOUBLE_EQUAL +## LR(1) items: +binExp -> exp DOUBLE_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 209 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 209: +## Known stack suffix: +## exp DOUBLE_EQUAL exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp DOUBLE_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN NOT_EQUAL LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production binExp -> exp DOUBLE_EQUAL exp + +State 210: +## Known stack suffix: +## exp OPEN_PAREN exp CLOSE_PAREN +## LR(1) items: +exp -> exp OPEN_PAREN exp CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> exp OPEN_PAREN exp CLOSE_PAREN + +State 211: +## Known stack suffix: +## filterAction exp IN +## LR(1) items: +exp -> filterAction exp IN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 212 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 212: +## Known stack suffix: +## filterAction exp IN exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> filterAction exp IN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> filterAction exp IN exp + +State 213: +## Known stack suffix: +## CASE exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +case -> CASE exp . list(rul) END [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +## Transitions: +-- On TURNSTILE shift to state 214 +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +-- On rul shift to state 218 +-- On list(rul) shift to state 220 +## Reductions: +-- On END +-- reduce production list(rul) -> + +State 214: +## Known stack suffix: +## TURNSTILE +## LR(1) items: +rul -> TURNSTILE . pat EQUAL_ARROW exp [ TURNSTILE END ] +## Transitions: +-- On WILD shift to state 61 +-- On TRUE shift to state 62 +-- On STRING shift to state 63 +-- On QUESTION shift to state 64 +-- On OPEN_SQUARE_BRACKET shift to state 67 +-- On OPEN_PAREN shift to state 68 +-- On INT shift to state 69 +-- On IDENT shift to state 70 +-- On FLOAT shift to state 71 +-- On FALSE shift to state 72 +-- On CONSTRUCTOR_IDENT shift to state 73 +-- On pat shift to state 215 +## Reductions: + +State 215: +## Known stack suffix: +## TURNSTILE pat +## LR(1) items: +pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY EQUAL_ARROW CONS COLON ] +pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY EQUAL_ARROW CONS COLON ] +pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY EQUAL_ARROW CONS COLON ] +pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY EQUAL_ARROW CONS COLON ] +rul -> TURNSTILE pat . EQUAL_ARROW exp [ TURNSTILE END ] +## Transitions: +-- On OPEN_PAREN shift to state 77 +-- On OPEN_CURLY shift to state 79 +-- On EQUAL_ARROW shift to state 216 +-- On CONS shift to state 84 +-- On COLON shift to state 86 +## Reductions: + +State 216: +## Known stack suffix: +## TURNSTILE pat EQUAL_ARROW +## LR(1) items: +rul -> TURNSTILE pat EQUAL_ARROW . exp [ TURNSTILE END ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 217 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 217: +## Known stack suffix: +## TURNSTILE pat EQUAL_ARROW exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +rul -> TURNSTILE pat EQUAL_ARROW exp . [ TURNSTILE END ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE END +-- reduce production rul -> TURNSTILE pat EQUAL_ARROW exp + +State 218: +## Known stack suffix: +## rul +## LR(1) items: +list(rul) -> rul . list(rul) [ END ] +## Transitions: +-- On TURNSTILE shift to state 214 +-- On rul shift to state 218 +-- On list(rul) shift to state 219 +## Reductions: +-- On END +-- reduce production list(rul) -> + +State 219: +## Known stack suffix: +## rul list(rul) +## LR(1) items: +list(rul) -> rul list(rul) . [ END ] +## Transitions: +## Reductions: +-- On END +-- reduce production list(rul) -> rul list(rul) + +State 220: +## Known stack suffix: +## CASE exp list(rul) +## LR(1) items: +case -> CASE exp list(rul) . END [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On END shift to state 221 +## Reductions: + +State 221: +## Known stack suffix: +## CASE exp list(rul) END +## LR(1) items: +case -> CASE exp list(rul) END . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production case -> CASE exp list(rul) END + +State 222: +## Known stack suffix: +## DOLLAR_SIGN exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +unExp -> DOLLAR_SIGN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production unExp -> DOLLAR_SIGN exp + +State 223: +## Known stack suffix: +## FIX pat DASH_ARROW exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> FIX pat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> FIX pat DASH_ARROW exp + +State 224: +## Known stack suffix: +## FUN pat DASH_ARROW exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +funExp -> FUN pat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production funExp -> FUN pat DASH_ARROW exp + +State 225: +## Known stack suffix: +## IF exp +## LR(1) items: +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> IF exp . THEN exp ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On THEN shift to state 226 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: + +State 226: +## Known stack suffix: +## IF exp THEN +## LR(1) items: +exp -> IF exp THEN . exp ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 227 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 227: +## Known stack suffix: +## IF exp THEN exp +## LR(1) items: +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> IF exp THEN exp . ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On ELSE shift to state 228 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: + +State 228: +## Known stack suffix: +## IF exp THEN exp ELSE +## LR(1) items: +exp -> IF exp THEN exp ELSE . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 229 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 229: +## Known stack suffix: +## IF exp THEN exp ELSE exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> IF exp THEN exp ELSE exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> IF exp THEN exp ELSE exp + +State 230: +## Known stack suffix: +## LESS_THAN LESS_THAN exp +## LR(1) items: +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> LESS_THAN LESS_THAN exp . QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 231 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: + +State 231: +## Known stack suffix: +## LESS_THAN LESS_THAN exp QUESTION +## LR(1) items: +exp -> exp QUESTION . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> LESS_THAN LESS_THAN exp QUESTION . SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On SEXP_STRING shift to state 232 +-- On OPEN_CURLY shift to state 149 +## Reductions: + +State 232: +## Known stack suffix: +## LESS_THAN LESS_THAN exp QUESTION SEXP_STRING +## LR(1) items: +exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING . GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On GREATER_THAN shift to state 233 +## Reductions: + +State 233: +## Known stack suffix: +## LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN +## LR(1) items: +exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN . GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On GREATER_THAN shift to state 234 +## Reductions: + +State 234: +## Known stack suffix: +## LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN +## LR(1) items: +exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN + +State 235: +## Known stack suffix: +## LET pat SINGLE_EQUAL exp +## LR(1) items: +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> LET pat SINGLE_EQUAL exp . IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On IN shift to state 236 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: + +State 236: +## Known stack suffix: +## LET pat SINGLE_EQUAL exp IN +## LR(1) items: +exp -> LET pat SINGLE_EQUAL exp IN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 237 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 237: +## Known stack suffix: +## LET pat SINGLE_EQUAL exp IN exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> LET pat SINGLE_EQUAL exp IN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> LET pat SINGLE_EQUAL exp IN exp + +State 238: +## Known stack suffix: +## L_NOT exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +unExp -> L_NOT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production unExp -> L_NOT exp + +State 239: +## Known stack suffix: +## MINUS exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +unExp -> MINUS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On MINUS_FLOAT shift to state 180 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production unExp -> MINUS exp + +State 240: +## Known stack suffix: +## NAMED_FUN IDENT pat DASH_ARROW exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +funExp -> NAMED_FUN IDENT pat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production funExp -> NAMED_FUN IDENT pat DASH_ARROW exp + +State 241: +## Known stack suffix: +## OPEN_PAREN exp +## LR(1) items: +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> OPEN_PAREN exp . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> OPEN_PAREN exp . COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On COMMA shift to state 242 +-- On CLOSE_PAREN shift to state 249 +-- On AT_SYMBOL shift to state 173 +## Reductions: + +State 242: +## Known stack suffix: +## OPEN_PAREN exp COMMA +## LR(1) items: +exp -> OPEN_PAREN exp COMMA . loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On separated_nonempty_list(COMMA,exp) shift to state 243 +-- On loption(separated_nonempty_list(COMMA,exp)) shift to state 244 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 246 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: +-- On CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,exp)) -> + +State 243: +## Known stack suffix: +## separated_nonempty_list(COMMA,exp) +## LR(1) items: +loption(separated_nonempty_list(COMMA,exp)) -> separated_nonempty_list(COMMA,exp) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production loption(separated_nonempty_list(COMMA,exp)) -> separated_nonempty_list(COMMA,exp) + +State 244: +## Known stack suffix: +## OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) +## LR(1) items: +exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On CLOSE_PAREN shift to state 245 +## Reductions: + +State 245: +## Known stack suffix: +## OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN +## LR(1) items: +exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN + +State 246: +## Known stack suffix: +## exp +## LR(1) items: +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +separated_nonempty_list(COMMA,exp) -> exp . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +separated_nonempty_list(COMMA,exp) -> exp . COMMA separated_nonempty_list(COMMA,exp) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On COMMA shift to state 247 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,exp) -> exp + +State 247: +## Known stack suffix: +## exp COMMA +## LR(1) items: +separated_nonempty_list(COMMA,exp) -> exp COMMA . separated_nonempty_list(COMMA,exp) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +-- On WILD shift to state 1 +-- On UNDEF shift to state 2 +-- On TYP_FUN shift to state 3 +-- On TYP shift to state 11 +-- On TRUE shift to state 50 +-- On TEST shift to state 51 +-- On STRING shift to state 52 +-- On QUESTION shift to state 53 +-- On PAUSE shift to state 56 +-- On OPEN_SQUARE_BRACKET shift to state 57 +-- On OPEN_PAREN shift to state 58 +-- On NAMED_FUN shift to state 59 +-- On MINUS shift to state 101 +-- On L_NOT shift to state 102 +-- On LET shift to state 103 +-- On LESS_THAN shift to state 106 +-- On INT shift to state 108 +-- On IF shift to state 109 +-- On IDENT shift to state 110 +-- On HIDE shift to state 111 +-- On FUN shift to state 112 +-- On FLOAT shift to state 115 +-- On FIX shift to state 116 +-- On FALSE shift to state 119 +-- On EVAL shift to state 120 +-- On DOLLAR_SIGN shift to state 121 +-- On DEBUG shift to state 122 +-- On CONSTRUCTOR_IDENT shift to state 123 +-- On CASE shift to state 128 +-- On BUILTIN shift to state 129 +-- On unExp shift to state 130 +-- On separated_nonempty_list(COMMA,exp) shift to state 248 +-- On funExp shift to state 131 +-- On filterAction shift to state 132 +-- On exp shift to state 246 +-- On case shift to state 138 +-- On binExp shift to state 139 +## Reductions: + +State 248: +## Known stack suffix: +## exp COMMA separated_nonempty_list(COMMA,exp) +## LR(1) items: +separated_nonempty_list(COMMA,exp) -> exp COMMA separated_nonempty_list(COMMA,exp) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] +## Transitions: +## Reductions: +-- On CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production separated_nonempty_list(COMMA,exp) -> exp COMMA separated_nonempty_list(COMMA,exp) + +State 249: +## Known stack suffix: +## OPEN_PAREN exp CLOSE_PAREN +## LR(1) items: +exp -> OPEN_PAREN exp CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> OPEN_PAREN exp CLOSE_PAREN + +State 250: +## Known stack suffix: +## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) +## LR(1) items: +exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) . CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On CLOSE_SQUARE_BRACKET shift to state 251 +## Reductions: + +State 251: +## Known stack suffix: +## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET +## LR(1) items: +exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET + +State 252: +## Known stack suffix: +## TEST exp +## LR(1) items: +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> TEST exp . END [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On END shift to state 253 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: + +State 253: +## Known stack suffix: +## TEST exp END +## LR(1) items: +exp -> TEST exp END . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> TEST exp END + +State 254: +## Known stack suffix: +## TYP tpat SINGLE_EQUAL typ IN exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> TYP tpat SINGLE_EQUAL typ IN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +## Reductions: +-- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL +-- reduce production exp -> TYP tpat SINGLE_EQUAL typ IN exp + +State 255: +## Known stack suffix: +## TYP_FUN tpat DASH_ARROW exp +## LR(1) items: +binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> TYP_FUN tpat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: +-- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN +-- reduce production exp -> TYP_FUN tpat DASH_ARROW exp + +State 256: +## Known stack suffix: +## program +## LR(1) items: +program' -> program . [ # ] +## Transitions: +## Reductions: +-- On # +-- accept program + +State 257: +## Known stack suffix: +## exp +## LR(1) items: +binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] +program -> exp . EOF [ # ] +## Transitions: +-- On TIMES_FLOAT shift to state 134 +-- On TIMES shift to state 158 +-- On STRING_EQUAL shift to state 136 +-- On STRING_CONCAT shift to state 140 +-- On SEMI_COLON shift to state 142 +-- On QUESTION shift to state 148 +-- On POWER_FLOAT shift to state 154 +-- On POWER shift to state 160 +-- On PLUS_FLOAT shift to state 162 +-- On PLUS shift to state 198 +-- On OPEN_PAREN shift to state 156 +-- On OPEN_CURLY shift to state 164 +-- On NOT_EQUAL_FLOAT shift to state 178 +-- On NOT_EQUAL shift to state 200 +-- On MINUS_FLOAT shift to state 180 +-- On MINUS shift to state 202 +-- On L_OR shift to state 144 +-- On L_AND shift to state 146 +-- On LESS_THAN_FLOAT shift to state 182 +-- On LESS_THAN_EQUAL_FLOAT shift to state 184 +-- On LESS_THAN_EQUAL shift to state 204 +-- On LESS_THAN shift to state 186 +-- On GREATER_THAN_FLOAT shift to state 188 +-- On GREATER_THAN_EQUAL_FLOAT shift to state 190 +-- On GREATER_THAN_EQUAL shift to state 206 +-- On GREATER_THAN shift to state 194 +-- On EOF shift to state 258 +-- On DOUBLE_EQUAL_FLOAT shift to state 192 +-- On DOUBLE_EQUAL shift to state 208 +-- On DIVIDE_FLOAT shift to state 169 +-- On DIVIDE shift to state 196 +-- On CONS shift to state 171 +-- On AT_SYMBOL shift to state 173 +## Reductions: + +State 258: +## Known stack suffix: +## exp EOF +## LR(1) items: +program -> exp EOF . [ # ] +## Transitions: +## Reductions: +-- On # +-- reduce production program -> exp EOF + diff --git a/src/haz3lmenhir/Parser.conflicts b/src/haz3lmenhir/Parser.conflicts new file mode 100644 index 0000000000..e191b7946a --- /dev/null +++ b/src/haz3lmenhir/Parser.conflicts @@ -0,0 +1,28 @@ + +** Conflict (shift/reduce) in state 41. +** Token involved: CLOSE_PAREN +** This state is reached from program after reading: + +CONSTRUCTOR_IDENT TILDE PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +program +exp EOF +CONSTRUCTOR_IDENT TILDE typ + sumTyp + (?) + +** In state 41, looking ahead at CLOSE_PAREN, reducing production +** separated_nonempty_list(COMMA,typ) -> typ +** is permitted because of the following sub-derivation: + +PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN // lookahead token appears + separated_nonempty_list(COMMA,typ) // lookahead token is inherited + typ . + +** In state 41, looking ahead at CLOSE_PAREN, shifting is permitted +** because of the following sub-derivation: + +PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ . CLOSE_PAREN diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 6f20eebfc8..6b92aa29bc 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -210,7 +210,8 @@ binExp: %inline sumTerm: - | i = CONSTRUCTOR_IDENT; t = tupleType { SumTerm(i, t) } + | i = CONSTRUCTOR_IDENT; t = tupleType { SumTerm(i, Some(t)) } + | i = CONSTRUCTOR_IDENT { SumTerm(i, None) } sumTyp: | PLUS; s = sumTerm; { SumTyp(s, None) } %prec SUM_TYP From 6391f8ef33a7b34ef3c77a72cd148561ec619462 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Mon, 2 Dec 2024 12:45:49 -0500 Subject: [PATCH 096/281] Removed parser automaton and conflicts --- src/haz3lmenhir/Parser.automaton | 7658 ------------------------------ src/haz3lmenhir/Parser.conflicts | 28 - 2 files changed, 7686 deletions(-) delete mode 100644 src/haz3lmenhir/Parser.automaton delete mode 100644 src/haz3lmenhir/Parser.conflicts diff --git a/src/haz3lmenhir/Parser.automaton b/src/haz3lmenhir/Parser.automaton deleted file mode 100644 index b85b68268d..0000000000 --- a/src/haz3lmenhir/Parser.automaton +++ /dev/null @@ -1,7658 +0,0 @@ -State 0: -## Known stack suffix: -## -## LR(1) items: -program' -> . program [ # ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On program shift to state 256 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 257 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 1: -## Known stack suffix: -## WILD -## LR(1) items: -exp -> WILD . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> WILD - -State 2: -## Known stack suffix: -## UNDEF -## LR(1) items: -exp -> UNDEF . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> UNDEF - -State 3: -## Known stack suffix: -## TYP_FUN -## LR(1) items: -exp -> TYP_FUN . tpat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On QUESTION shift to state 4 --- On IDENT shift to state 7 --- On CONSTRUCTOR_IDENT shift to state 8 --- On tpat shift to state 9 -## Reductions: - -State 4: -## Known stack suffix: -## QUESTION -## LR(1) items: -tpat -> QUESTION . TP_TPAT STRING [ SINGLE_EQUAL DASH_ARROW ] -tpat -> QUESTION . [ SINGLE_EQUAL DASH_ARROW ] -## Transitions: --- On TP_TPAT shift to state 5 -## Reductions: --- On SINGLE_EQUAL DASH_ARROW --- reduce production tpat -> QUESTION - -State 5: -## Known stack suffix: -## QUESTION TP_TPAT -## LR(1) items: -tpat -> QUESTION TP_TPAT . STRING [ SINGLE_EQUAL DASH_ARROW ] -## Transitions: --- On STRING shift to state 6 -## Reductions: - -State 6: -## Known stack suffix: -## QUESTION TP_TPAT STRING -## LR(1) items: -tpat -> QUESTION TP_TPAT STRING . [ SINGLE_EQUAL DASH_ARROW ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL DASH_ARROW --- reduce production tpat -> QUESTION TP_TPAT STRING - -State 7: -## Known stack suffix: -## IDENT -## LR(1) items: -tpat -> IDENT . [ SINGLE_EQUAL DASH_ARROW ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL DASH_ARROW --- reduce production tpat -> IDENT - -State 8: -## Known stack suffix: -## CONSTRUCTOR_IDENT -## LR(1) items: -tpat -> CONSTRUCTOR_IDENT . [ SINGLE_EQUAL DASH_ARROW ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL DASH_ARROW --- reduce production tpat -> CONSTRUCTOR_IDENT - -State 9: -## Known stack suffix: -## TYP_FUN tpat -## LR(1) items: -exp -> TYP_FUN tpat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On DASH_ARROW shift to state 10 -## Reductions: - -State 10: -## Known stack suffix: -## TYP_FUN tpat DASH_ARROW -## LR(1) items: -exp -> TYP_FUN tpat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 255 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 11: -## Known stack suffix: -## TYP -## LR(1) items: -exp -> TYP . tpat SINGLE_EQUAL typ IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On QUESTION shift to state 4 --- On IDENT shift to state 7 --- On CONSTRUCTOR_IDENT shift to state 8 --- On tpat shift to state 12 -## Reductions: - -State 12: -## Known stack suffix: -## TYP tpat -## LR(1) items: -exp -> TYP tpat . SINGLE_EQUAL typ IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SINGLE_EQUAL shift to state 13 -## Reductions: - -State 13: -## Known stack suffix: -## TYP tpat SINGLE_EQUAL -## LR(1) items: -exp -> TYP tpat SINGLE_EQUAL . typ IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 48 --- On sumTyp shift to state 33 -## Reductions: - -State 14: -## Known stack suffix: -## UNKNOWN -## LR(1) items: -typ -> UNKNOWN . INTERNAL [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On INTERNAL shift to state 15 -## Reductions: - -State 15: -## Known stack suffix: -## UNKNOWN INTERNAL -## LR(1) items: -typ -> UNKNOWN INTERNAL . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production typ -> UNKNOWN INTERNAL - -State 16: -## Known stack suffix: -## UNIT -## LR(1) items: -typ -> UNIT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production typ -> UNIT - -State 17: -## Known stack suffix: -## STRING_TYPE -## LR(1) items: -typ -> STRING_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production typ -> STRING_TYPE - -State 18: -## Known stack suffix: -## QUESTION -## LR(1) items: -typ -> QUESTION . T_TYP STRING [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On T_TYP shift to state 19 -## Reductions: - -State 19: -## Known stack suffix: -## QUESTION T_TYP -## LR(1) items: -typ -> QUESTION T_TYP . STRING [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On STRING shift to state 20 -## Reductions: - -State 20: -## Known stack suffix: -## QUESTION T_TYP STRING -## LR(1) items: -typ -> QUESTION T_TYP STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production typ -> QUESTION T_TYP STRING - -State 21: -## Known stack suffix: -## PLUS -## LR(1) items: -sumTyp -> PLUS . CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS . CONSTRUCTOR_IDENT [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS . CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS . CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS . CONSTRUCTOR_IDENT sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS . CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On CONSTRUCTOR_IDENT shift to state 22 -## Reductions: - -State 22: -## Known stack suffix: -## PLUS CONSTRUCTOR_IDENT -## LR(1) items: -sumTyp -> PLUS CONSTRUCTOR_IDENT . OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS CONSTRUCTOR_IDENT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS CONSTRUCTOR_IDENT . OPEN_PAREN typ CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS CONSTRUCTOR_IDENT . OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS CONSTRUCTOR_IDENT . sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS CONSTRUCTOR_IDENT . OPEN_PAREN typ CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On PLUS shift to state 21 --- On OPEN_PAREN shift to state 23 --- On sumTyp shift to state 47 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production sumTyp -> PLUS CONSTRUCTOR_IDENT - -State 23: -## Known stack suffix: -## PLUS CONSTRUCTOR_IDENT OPEN_PAREN -## LR(1) items: -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN . loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN . typ CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN . loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN . typ CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 41 --- On sumTyp shift to state 33 --- On separated_nonempty_list(COMMA,typ) shift to state 36 --- On loption(separated_nonempty_list(COMMA,typ)) shift to state 44 -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,typ)) -> - -State 24: -## Known stack suffix: -## OPEN_SQUARE_BRACKET -## LR(1) items: -typ -> OPEN_SQUARE_BRACKET . typ CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 39 --- On sumTyp shift to state 33 -## Reductions: - -State 25: -## Known stack suffix: -## OPEN_PAREN -## LR(1) items: -typ -> OPEN_PAREN . loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 30 --- On sumTyp shift to state 33 --- On separated_nonempty_list(COMMA,typ) shift to state 36 --- On loption(separated_nonempty_list(COMMA,typ)) shift to state 37 -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,typ)) -> - -State 26: -## Known stack suffix: -## INT_TYPE -## LR(1) items: -typ -> INT_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production typ -> INT_TYPE - -State 27: -## Known stack suffix: -## FLOAT_TYPE -## LR(1) items: -typ -> FLOAT_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production typ -> FLOAT_TYPE - -State 28: -## Known stack suffix: -## CONSTRUCTOR_IDENT -## LR(1) items: -typ -> CONSTRUCTOR_IDENT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production typ -> CONSTRUCTOR_IDENT - -State 29: -## Known stack suffix: -## BOOL_TYPE -## LR(1) items: -typ -> BOOL_TYPE . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production typ -> BOOL_TYPE - -State 30: -## Known stack suffix: -## typ -## LR(1) items: -separated_nonempty_list(COMMA,typ) -> typ . [ CLOSE_PAREN ] -separated_nonempty_list(COMMA,typ) -> typ . COMMA separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ DASH_ARROW COMMA CLOSE_PAREN ] -## Transitions: --- On DASH_ARROW shift to state 31 --- On COMMA shift to state 34 -## Reductions: --- On CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,typ) -> typ - -State 31: -## Known stack suffix: -## typ DASH_ARROW -## LR(1) items: -typ -> typ DASH_ARROW . typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 32 --- On sumTyp shift to state 33 -## Reductions: - -State 32: -## Known stack suffix: -## typ DASH_ARROW typ -## LR(1) items: -typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -typ -> typ DASH_ARROW typ . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production typ -> typ DASH_ARROW typ - -State 33: -## Known stack suffix: -## sumTyp -## LR(1) items: -typ -> sumTyp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production typ -> sumTyp - -State 34: -## Known stack suffix: -## typ COMMA -## LR(1) items: -separated_nonempty_list(COMMA,typ) -> typ COMMA . separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 30 --- On sumTyp shift to state 33 --- On separated_nonempty_list(COMMA,typ) shift to state 35 -## Reductions: - -State 35: -## Known stack suffix: -## typ COMMA separated_nonempty_list(COMMA,typ) -## LR(1) items: -separated_nonempty_list(COMMA,typ) -> typ COMMA separated_nonempty_list(COMMA,typ) . [ CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,typ) -> typ COMMA separated_nonempty_list(COMMA,typ) - -State 36: -## Known stack suffix: -## separated_nonempty_list(COMMA,typ) -## LR(1) items: -loption(separated_nonempty_list(COMMA,typ)) -> separated_nonempty_list(COMMA,typ) . [ CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,typ)) -> separated_nonempty_list(COMMA,typ) - -State 37: -## Known stack suffix: -## OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) -## LR(1) items: -typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On CLOSE_PAREN shift to state 38 -## Reductions: - -State 38: -## Known stack suffix: -## OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN -## LR(1) items: -typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production typ -> OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN - -State 39: -## Known stack suffix: -## OPEN_SQUARE_BRACKET typ -## LR(1) items: -typ -> OPEN_SQUARE_BRACKET typ . CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ DASH_ARROW CLOSE_SQUARE_BRACKET ] -## Transitions: --- On DASH_ARROW shift to state 31 --- On CLOSE_SQUARE_BRACKET shift to state 40 -## Reductions: - -State 40: -## Known stack suffix: -## OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET -## LR(1) items: -typ -> OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production typ -> OPEN_SQUARE_BRACKET typ CLOSE_SQUARE_BRACKET - -State 41: -## Known stack suffix: -## PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ -## LR(1) items: -separated_nonempty_list(COMMA,typ) -> typ . [ CLOSE_PAREN ] -separated_nonempty_list(COMMA,typ) -> typ . COMMA separated_nonempty_list(COMMA,typ) [ CLOSE_PAREN ] -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ . CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ DASH_ARROW COMMA CLOSE_PAREN ] -## Transitions: --- On DASH_ARROW shift to state 31 --- On COMMA shift to state 34 --- On CLOSE_PAREN shift to state 42 -## Reductions: --- On CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,typ) -> typ -** Conflict on CLOSE_PAREN - -State 42: -## Known stack suffix: -## PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN -## LR(1) items: -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN . sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On PLUS shift to state 21 --- On sumTyp shift to state 43 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN - -State 43: -## Known stack suffix: -## PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN sumTyp -## LR(1) items: -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN sumTyp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ CLOSE_PAREN sumTyp - -State 44: -## Known stack suffix: -## PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) -## LR(1) items: -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) . CLOSE_PAREN sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On CLOSE_PAREN shift to state 45 -## Reductions: - -State 45: -## Known stack suffix: -## PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN -## LR(1) items: -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN . sumTyp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: --- On PLUS shift to state 21 --- On sumTyp shift to state 46 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN - -State 46: -## Known stack suffix: -## PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN sumTyp -## LR(1) items: -sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN sumTyp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production sumTyp -> PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN sumTyp - -State 47: -## Known stack suffix: -## PLUS CONSTRUCTOR_IDENT sumTyp -## LR(1) items: -sumTyp -> PLUS CONSTRUCTOR_IDENT sumTyp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SINGLE_EQUAL SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EQUAL_ARROW EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN CLOSE_CURLY AT_SYMBOL --- reduce production sumTyp -> PLUS CONSTRUCTOR_IDENT sumTyp - -State 48: -## Known stack suffix: -## TYP tpat SINGLE_EQUAL typ -## LR(1) items: -exp -> TYP tpat SINGLE_EQUAL typ . IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ IN DASH_ARROW ] -## Transitions: --- On IN shift to state 49 --- On DASH_ARROW shift to state 31 -## Reductions: - -State 49: -## Known stack suffix: -## TYP tpat SINGLE_EQUAL typ IN -## LR(1) items: -exp -> TYP tpat SINGLE_EQUAL typ IN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 254 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 50: -## Known stack suffix: -## TRUE -## LR(1) items: -exp -> TRUE . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> TRUE - -State 51: -## Known stack suffix: -## TEST -## LR(1) items: -exp -> TEST . exp END [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 252 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 52: -## Known stack suffix: -## STRING -## LR(1) items: -exp -> STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> STRING - -State 53: -## Known stack suffix: -## QUESTION -## LR(1) items: -exp -> QUESTION . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> QUESTION . E_EXP STRING [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On E_EXP shift to state 54 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> QUESTION - -State 54: -## Known stack suffix: -## QUESTION E_EXP -## LR(1) items: -exp -> QUESTION E_EXP . STRING [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING shift to state 55 -## Reductions: - -State 55: -## Known stack suffix: -## QUESTION E_EXP STRING -## LR(1) items: -exp -> QUESTION E_EXP STRING . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> QUESTION E_EXP STRING - -State 56: -## Known stack suffix: -## PAUSE -## LR(1) items: -filterAction -> PAUSE . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] -## Transitions: -## Reductions: --- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN --- reduce production filterAction -> PAUSE - -State 57: -## Known stack suffix: -## OPEN_SQUARE_BRACKET -## LR(1) items: -exp -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On separated_nonempty_list(COMMA,exp) shift to state 243 --- On loption(separated_nonempty_list(COMMA,exp)) shift to state 250 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 246 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: --- On CLOSE_SQUARE_BRACKET --- reduce production loption(separated_nonempty_list(COMMA,exp)) -> - -State 58: -## Known stack suffix: -## OPEN_PAREN -## LR(1) items: -exp -> OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> OPEN_PAREN . exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 241 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 59: -## Known stack suffix: -## NAMED_FUN -## LR(1) items: -funExp -> NAMED_FUN . IDENT pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On IDENT shift to state 60 -## Reductions: - -State 60: -## Known stack suffix: -## NAMED_FUN IDENT -## LR(1) items: -funExp -> NAMED_FUN IDENT . pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 61 --- On TRUE shift to state 62 --- On STRING shift to state 63 --- On QUESTION shift to state 64 --- On OPEN_SQUARE_BRACKET shift to state 67 --- On OPEN_PAREN shift to state 68 --- On INT shift to state 69 --- On IDENT shift to state 70 --- On FLOAT shift to state 71 --- On FALSE shift to state 72 --- On CONSTRUCTOR_IDENT shift to state 73 --- On pat shift to state 99 -## Reductions: - -State 61: -## Known stack suffix: -## WILD -## LR(1) items: -pat -> WILD . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> WILD - -State 62: -## Known stack suffix: -## TRUE -## LR(1) items: -pat -> TRUE . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> TRUE - -State 63: -## Known stack suffix: -## STRING -## LR(1) items: -pat -> STRING . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> STRING - -State 64: -## Known stack suffix: -## QUESTION -## LR(1) items: -pat -> QUESTION . P_PAT STRING [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> QUESTION . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On P_PAT shift to state 65 -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> QUESTION - -State 65: -## Known stack suffix: -## QUESTION P_PAT -## LR(1) items: -pat -> QUESTION P_PAT . STRING [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On STRING shift to state 66 -## Reductions: - -State 66: -## Known stack suffix: -## QUESTION P_PAT STRING -## LR(1) items: -pat -> QUESTION P_PAT STRING . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> QUESTION P_PAT STRING - -State 67: -## Known stack suffix: -## OPEN_SQUARE_BRACKET -## LR(1) items: -pat -> OPEN_SQUARE_BRACKET . loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 61 --- On TRUE shift to state 62 --- On STRING shift to state 63 --- On QUESTION shift to state 64 --- On OPEN_SQUARE_BRACKET shift to state 67 --- On OPEN_PAREN shift to state 68 --- On INT shift to state 69 --- On IDENT shift to state 70 --- On FLOAT shift to state 71 --- On FALSE shift to state 72 --- On CONSTRUCTOR_IDENT shift to state 73 --- On separated_nonempty_list(COMMA,pat) shift to state 90 --- On pat shift to state 91 --- On loption(separated_nonempty_list(COMMA,pat)) shift to state 97 -## Reductions: --- On CLOSE_SQUARE_BRACKET --- reduce production loption(separated_nonempty_list(COMMA,pat)) -> - -State 68: -## Known stack suffix: -## OPEN_PAREN -## LR(1) items: -pat -> OPEN_PAREN . pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> OPEN_PAREN . pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 61 --- On TRUE shift to state 62 --- On STRING shift to state 63 --- On QUESTION shift to state 64 --- On OPEN_SQUARE_BRACKET shift to state 67 --- On OPEN_PAREN shift to state 68 --- On INT shift to state 69 --- On IDENT shift to state 70 --- On FLOAT shift to state 71 --- On FALSE shift to state 72 --- On CONSTRUCTOR_IDENT shift to state 73 --- On pat shift to state 76 -## Reductions: - -State 69: -## Known stack suffix: -## INT -## LR(1) items: -pat -> INT . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> INT - -State 70: -## Known stack suffix: -## IDENT -## LR(1) items: -pat -> IDENT . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> IDENT - -State 71: -## Known stack suffix: -## FLOAT -## LR(1) items: -pat -> FLOAT . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> FLOAT - -State 72: -## Known stack suffix: -## FALSE -## LR(1) items: -pat -> FALSE . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> FALSE - -State 73: -## Known stack suffix: -## CONSTRUCTOR_IDENT -## LR(1) items: -pat -> CONSTRUCTOR_IDENT . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> CONSTRUCTOR_IDENT . TILDE typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On TILDE shift to state 74 -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> CONSTRUCTOR_IDENT - -State 74: -## Known stack suffix: -## CONSTRUCTOR_IDENT TILDE -## LR(1) items: -pat -> CONSTRUCTOR_IDENT TILDE . typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 75 --- On sumTyp shift to state 33 -## Reductions: - -State 75: -## Known stack suffix: -## CONSTRUCTOR_IDENT TILDE typ -## LR(1) items: -pat -> CONSTRUCTOR_IDENT TILDE typ . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> CONSTRUCTOR_IDENT TILDE typ - -State 76: -## Known stack suffix: -## OPEN_PAREN pat -## LR(1) items: -pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_PAREN ] -pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_PAREN ] -pat -> OPEN_PAREN pat . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> OPEN_PAREN pat . COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_PAREN ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_PAREN ] -## Transitions: --- On OPEN_PAREN shift to state 77 --- On OPEN_CURLY shift to state 79 --- On CONS shift to state 84 --- On COMMA shift to state 89 --- On COLON shift to state 86 --- On CLOSE_PAREN shift to state 96 -## Reductions: - -State 77: -## Known stack suffix: -## pat OPEN_PAREN -## LR(1) items: -pat -> pat OPEN_PAREN . pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 61 --- On TRUE shift to state 62 --- On STRING shift to state 63 --- On QUESTION shift to state 64 --- On OPEN_SQUARE_BRACKET shift to state 67 --- On OPEN_PAREN shift to state 68 --- On INT shift to state 69 --- On IDENT shift to state 70 --- On FLOAT shift to state 71 --- On FALSE shift to state 72 --- On CONSTRUCTOR_IDENT shift to state 73 --- On pat shift to state 78 -## Reductions: - -State 78: -## Known stack suffix: -## pat OPEN_PAREN pat -## LR(1) items: -pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY CONS COLON CLOSE_PAREN ] -pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY CONS COLON CLOSE_PAREN ] -pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY CONS COLON CLOSE_PAREN ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY CONS COLON CLOSE_PAREN ] -pat -> pat OPEN_PAREN pat . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On OPEN_PAREN shift to state 77 --- On OPEN_CURLY shift to state 79 --- On CONS shift to state 84 --- On COLON shift to state 86 --- On CLOSE_PAREN shift to state 88 -## Reductions: - -State 79: -## Known stack suffix: -## pat OPEN_CURLY -## LR(1) items: -pat -> pat OPEN_CURLY . typ EQUAL_ARROW typ CLOSE_CURLY [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 80 --- On sumTyp shift to state 33 -## Reductions: - -State 80: -## Known stack suffix: -## pat OPEN_CURLY typ -## LR(1) items: -pat -> pat OPEN_CURLY typ . EQUAL_ARROW typ CLOSE_CURLY [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] -## Transitions: --- On EQUAL_ARROW shift to state 81 --- On DASH_ARROW shift to state 31 -## Reductions: - -State 81: -## Known stack suffix: -## pat OPEN_CURLY typ EQUAL_ARROW -## LR(1) items: -pat -> pat OPEN_CURLY typ EQUAL_ARROW . typ CLOSE_CURLY [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 82 --- On sumTyp shift to state 33 -## Reductions: - -State 82: -## Known stack suffix: -## pat OPEN_CURLY typ EQUAL_ARROW typ -## LR(1) items: -pat -> pat OPEN_CURLY typ EQUAL_ARROW typ . CLOSE_CURLY [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ DASH_ARROW CLOSE_CURLY ] -## Transitions: --- On DASH_ARROW shift to state 31 --- On CLOSE_CURLY shift to state 83 -## Reductions: - -State 83: -## Known stack suffix: -## pat OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY -## LR(1) items: -pat -> pat OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> pat OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY - -State 84: -## Known stack suffix: -## pat CONS -## LR(1) items: -pat -> pat CONS . pat [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 61 --- On TRUE shift to state 62 --- On STRING shift to state 63 --- On QUESTION shift to state 64 --- On OPEN_SQUARE_BRACKET shift to state 67 --- On OPEN_PAREN shift to state 68 --- On INT shift to state 69 --- On IDENT shift to state 70 --- On FLOAT shift to state 71 --- On FALSE shift to state 72 --- On CONSTRUCTOR_IDENT shift to state 73 --- On pat shift to state 85 -## Reductions: - -State 85: -## Known stack suffix: -## pat CONS pat -## LR(1) items: -pat -> pat . COLON typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . CONS pat [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat CONS pat . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On OPEN_PAREN shift to state 77 -## Reductions: --- On SINGLE_EQUAL OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> pat CONS pat - -State 86: -## Known stack suffix: -## pat COLON -## LR(1) items: -pat -> pat COLON . typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 87 --- On sumTyp shift to state 33 -## Reductions: - -State 87: -## Known stack suffix: -## pat COLON typ -## LR(1) items: -pat -> pat COLON typ . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -typ -> typ . DASH_ARROW typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On DASH_ARROW shift to state 31 -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> pat COLON typ - -State 88: -## Known stack suffix: -## pat OPEN_PAREN pat CLOSE_PAREN -## LR(1) items: -pat -> pat OPEN_PAREN pat CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> pat OPEN_PAREN pat CLOSE_PAREN - -State 89: -## Known stack suffix: -## OPEN_PAREN pat COMMA -## LR(1) items: -pat -> OPEN_PAREN pat COMMA . loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 61 --- On TRUE shift to state 62 --- On STRING shift to state 63 --- On QUESTION shift to state 64 --- On OPEN_SQUARE_BRACKET shift to state 67 --- On OPEN_PAREN shift to state 68 --- On INT shift to state 69 --- On IDENT shift to state 70 --- On FLOAT shift to state 71 --- On FALSE shift to state 72 --- On CONSTRUCTOR_IDENT shift to state 73 --- On separated_nonempty_list(COMMA,pat) shift to state 90 --- On pat shift to state 91 --- On loption(separated_nonempty_list(COMMA,pat)) shift to state 94 -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,pat)) -> - -State 90: -## Known stack suffix: -## separated_nonempty_list(COMMA,pat) -## LR(1) items: -loption(separated_nonempty_list(COMMA,pat)) -> separated_nonempty_list(COMMA,pat) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,pat)) -> separated_nonempty_list(COMMA,pat) - -State 91: -## Known stack suffix: -## pat -## LR(1) items: -pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -separated_nonempty_list(COMMA,pat) -> pat . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -separated_nonempty_list(COMMA,pat) -> pat . COMMA separated_nonempty_list(COMMA,pat) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On OPEN_PAREN shift to state 77 --- On OPEN_CURLY shift to state 79 --- On CONS shift to state 84 --- On COMMA shift to state 92 --- On COLON shift to state 86 -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,pat) -> pat - -State 92: -## Known stack suffix: -## pat COMMA -## LR(1) items: -separated_nonempty_list(COMMA,pat) -> pat COMMA . separated_nonempty_list(COMMA,pat) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 61 --- On TRUE shift to state 62 --- On STRING shift to state 63 --- On QUESTION shift to state 64 --- On OPEN_SQUARE_BRACKET shift to state 67 --- On OPEN_PAREN shift to state 68 --- On INT shift to state 69 --- On IDENT shift to state 70 --- On FLOAT shift to state 71 --- On FALSE shift to state 72 --- On CONSTRUCTOR_IDENT shift to state 73 --- On separated_nonempty_list(COMMA,pat) shift to state 93 --- On pat shift to state 91 -## Reductions: - -State 93: -## Known stack suffix: -## pat COMMA separated_nonempty_list(COMMA,pat) -## LR(1) items: -separated_nonempty_list(COMMA,pat) -> pat COMMA separated_nonempty_list(COMMA,pat) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,pat) -> pat COMMA separated_nonempty_list(COMMA,pat) - -State 94: -## Known stack suffix: -## OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) -## LR(1) items: -pat -> OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) . CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On CLOSE_PAREN shift to state 95 -## Reductions: - -State 95: -## Known stack suffix: -## OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN -## LR(1) items: -pat -> OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> OPEN_PAREN pat COMMA loption(separated_nonempty_list(COMMA,pat)) CLOSE_PAREN - -State 96: -## Known stack suffix: -## OPEN_PAREN pat CLOSE_PAREN -## LR(1) items: -pat -> OPEN_PAREN pat CLOSE_PAREN . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> OPEN_PAREN pat CLOSE_PAREN - -State 97: -## Known stack suffix: -## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) -## LR(1) items: -pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) . CLOSE_SQUARE_BRACKET [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On CLOSE_SQUARE_BRACKET shift to state 98 -## Reductions: - -State 98: -## Known stack suffix: -## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET -## LR(1) items: -pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET . [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On SINGLE_EQUAL OPEN_PAREN OPEN_CURLY EQUAL_ARROW DASH_ARROW CONS COMMA COLON CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production pat -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,pat)) CLOSE_SQUARE_BRACKET - -State 99: -## Known stack suffix: -## NAMED_FUN IDENT pat -## LR(1) items: -funExp -> NAMED_FUN IDENT pat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] -pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] -pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] -## Transitions: --- On OPEN_PAREN shift to state 77 --- On OPEN_CURLY shift to state 79 --- On DASH_ARROW shift to state 100 --- On CONS shift to state 84 --- On COLON shift to state 86 -## Reductions: - -State 100: -## Known stack suffix: -## NAMED_FUN IDENT pat DASH_ARROW -## LR(1) items: -funExp -> NAMED_FUN IDENT pat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 240 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 101: -## Known stack suffix: -## MINUS -## LR(1) items: -unExp -> MINUS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 239 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 102: -## Known stack suffix: -## L_NOT -## LR(1) items: -unExp -> L_NOT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 238 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 103: -## Known stack suffix: -## LET -## LR(1) items: -exp -> LET . pat SINGLE_EQUAL exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 61 --- On TRUE shift to state 62 --- On STRING shift to state 63 --- On QUESTION shift to state 64 --- On OPEN_SQUARE_BRACKET shift to state 67 --- On OPEN_PAREN shift to state 68 --- On INT shift to state 69 --- On IDENT shift to state 70 --- On FLOAT shift to state 71 --- On FALSE shift to state 72 --- On CONSTRUCTOR_IDENT shift to state 73 --- On pat shift to state 104 -## Reductions: - -State 104: -## Known stack suffix: -## LET pat -## LR(1) items: -exp -> LET pat . SINGLE_EQUAL exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -pat -> pat . COLON typ [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY CONS COLON ] -pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY CONS COLON ] -pat -> pat . CONS pat [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY CONS COLON ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ SINGLE_EQUAL OPEN_PAREN OPEN_CURLY CONS COLON ] -## Transitions: --- On SINGLE_EQUAL shift to state 105 --- On OPEN_PAREN shift to state 77 --- On OPEN_CURLY shift to state 79 --- On CONS shift to state 84 --- On COLON shift to state 86 -## Reductions: - -State 105: -## Known stack suffix: -## LET pat SINGLE_EQUAL -## LR(1) items: -exp -> LET pat SINGLE_EQUAL . exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 235 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 106: -## Known stack suffix: -## LESS_THAN -## LR(1) items: -exp -> LESS_THAN . LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On LESS_THAN shift to state 107 -## Reductions: - -State 107: -## Known stack suffix: -## LESS_THAN LESS_THAN -## LR(1) items: -exp -> LESS_THAN LESS_THAN . exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 230 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 108: -## Known stack suffix: -## INT -## LR(1) items: -exp -> INT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> INT - -State 109: -## Known stack suffix: -## IF -## LR(1) items: -exp -> IF . exp THEN exp ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 225 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 110: -## Known stack suffix: -## IDENT -## LR(1) items: -exp -> IDENT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> IDENT - -State 111: -## Known stack suffix: -## HIDE -## LR(1) items: -filterAction -> HIDE . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] -## Transitions: -## Reductions: --- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN --- reduce production filterAction -> HIDE - -State 112: -## Known stack suffix: -## FUN -## LR(1) items: -funExp -> FUN . pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 61 --- On TRUE shift to state 62 --- On STRING shift to state 63 --- On QUESTION shift to state 64 --- On OPEN_SQUARE_BRACKET shift to state 67 --- On OPEN_PAREN shift to state 68 --- On INT shift to state 69 --- On IDENT shift to state 70 --- On FLOAT shift to state 71 --- On FALSE shift to state 72 --- On CONSTRUCTOR_IDENT shift to state 73 --- On pat shift to state 113 -## Reductions: - -State 113: -## Known stack suffix: -## FUN pat -## LR(1) items: -funExp -> FUN pat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] -pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] -pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] -## Transitions: --- On OPEN_PAREN shift to state 77 --- On OPEN_CURLY shift to state 79 --- On DASH_ARROW shift to state 114 --- On CONS shift to state 84 --- On COLON shift to state 86 -## Reductions: - -State 114: -## Known stack suffix: -## FUN pat DASH_ARROW -## LR(1) items: -funExp -> FUN pat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 224 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 115: -## Known stack suffix: -## FLOAT -## LR(1) items: -exp -> FLOAT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> FLOAT - -State 116: -## Known stack suffix: -## FIX -## LR(1) items: -exp -> FIX . pat DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 61 --- On TRUE shift to state 62 --- On STRING shift to state 63 --- On QUESTION shift to state 64 --- On OPEN_SQUARE_BRACKET shift to state 67 --- On OPEN_PAREN shift to state 68 --- On INT shift to state 69 --- On IDENT shift to state 70 --- On FLOAT shift to state 71 --- On FALSE shift to state 72 --- On CONSTRUCTOR_IDENT shift to state 73 --- On pat shift to state 117 -## Reductions: - -State 117: -## Known stack suffix: -## FIX pat -## LR(1) items: -exp -> FIX pat . DASH_ARROW exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] -pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] -pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY DASH_ARROW CONS COLON ] -## Transitions: --- On OPEN_PAREN shift to state 77 --- On OPEN_CURLY shift to state 79 --- On DASH_ARROW shift to state 118 --- On CONS shift to state 84 --- On COLON shift to state 86 -## Reductions: - -State 118: -## Known stack suffix: -## FIX pat DASH_ARROW -## LR(1) items: -exp -> FIX pat DASH_ARROW . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 223 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 119: -## Known stack suffix: -## FALSE -## LR(1) items: -exp -> FALSE . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> FALSE - -State 120: -## Known stack suffix: -## EVAL -## LR(1) items: -filterAction -> EVAL . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] -## Transitions: -## Reductions: --- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN --- reduce production filterAction -> EVAL - -State 121: -## Known stack suffix: -## DOLLAR_SIGN -## LR(1) items: -unExp -> DOLLAR_SIGN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 222 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 122: -## Known stack suffix: -## DEBUG -## LR(1) items: -filterAction -> DEBUG . [ WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN ] -## Transitions: -## Reductions: --- On WILD UNDEF TYP_FUN TYP TRUE TEST STRING QUESTION PAUSE OPEN_SQUARE_BRACKET OPEN_PAREN NAMED_FUN MINUS L_NOT LET LESS_THAN INT IF IDENT HIDE FUN FLOAT FIX FALSE EVAL DOLLAR_SIGN DEBUG CONSTRUCTOR_IDENT CASE BUILTIN --- reduce production filterAction -> DEBUG - -State 123: -## Known stack suffix: -## CONSTRUCTOR_IDENT -## LR(1) items: -exp -> CONSTRUCTOR_IDENT . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> CONSTRUCTOR_IDENT . TILDE typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> CONSTRUCTOR_IDENT . COLON typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TILDE shift to state 124 --- On COLON shift to state 126 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> CONSTRUCTOR_IDENT - -State 124: -## Known stack suffix: -## CONSTRUCTOR_IDENT TILDE -## LR(1) items: -exp -> CONSTRUCTOR_IDENT TILDE . typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 125 --- On sumTyp shift to state 33 -## Reductions: - -State 125: -## Known stack suffix: -## CONSTRUCTOR_IDENT TILDE typ -## LR(1) items: -exp -> CONSTRUCTOR_IDENT TILDE typ . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On DASH_ARROW shift to state 31 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> CONSTRUCTOR_IDENT TILDE typ - -State 126: -## Known stack suffix: -## CONSTRUCTOR_IDENT COLON -## LR(1) items: -exp -> CONSTRUCTOR_IDENT COLON . typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 127 --- On sumTyp shift to state 33 -## Reductions: - -State 127: -## Known stack suffix: -## CONSTRUCTOR_IDENT COLON typ -## LR(1) items: -exp -> CONSTRUCTOR_IDENT COLON typ . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE DASH_ARROW CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On DASH_ARROW shift to state 31 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> CONSTRUCTOR_IDENT COLON typ - -State 128: -## Known stack suffix: -## CASE -## LR(1) items: -case -> CASE . exp list(rul) END [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 213 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 129: -## Known stack suffix: -## BUILTIN -## LR(1) items: -exp -> BUILTIN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> BUILTIN - -State 130: -## Known stack suffix: -## unExp -## LR(1) items: -exp -> unExp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> unExp - -State 131: -## Known stack suffix: -## funExp -## LR(1) items: -exp -> funExp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> funExp - -State 132: -## Known stack suffix: -## filterAction -## LR(1) items: -exp -> filterAction . exp IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 133 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 133: -## Known stack suffix: -## filterAction exp -## LR(1) items: -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> filterAction exp . IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On IN shift to state 211 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: - -State 134: -## Known stack suffix: -## exp TIMES_FLOAT -## LR(1) items: -binExp -> exp TIMES_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 135 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 135: -## Known stack suffix: -## exp TIMES_FLOAT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp TIMES_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp TIMES_FLOAT exp - -State 136: -## Known stack suffix: -## exp STRING_EQUAL -## LR(1) items: -binExp -> exp STRING_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 137 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 137: -## Known stack suffix: -## exp STRING_EQUAL exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp STRING_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production binExp -> exp STRING_EQUAL exp - -State 138: -## Known stack suffix: -## case -## LR(1) items: -exp -> case . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> case - -State 139: -## Known stack suffix: -## binExp -## LR(1) items: -exp -> binExp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> binExp - -State 140: -## Known stack suffix: -## exp STRING_CONCAT -## LR(1) items: -binExp -> exp STRING_CONCAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 141 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 141: -## Known stack suffix: -## exp STRING_CONCAT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp STRING_CONCAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production binExp -> exp STRING_CONCAT exp - -State 142: -## Known stack suffix: -## exp SEMI_COLON -## LR(1) items: -exp -> exp SEMI_COLON . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 143 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 143: -## Known stack suffix: -## exp SEMI_COLON exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp SEMI_COLON exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On L_OR shift to state 144 --- On L_AND shift to state 146 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> exp SEMI_COLON exp - -State 144: -## Known stack suffix: -## exp L_OR -## LR(1) items: -binExp -> exp L_OR . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 145 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 145: -## Known stack suffix: -## exp L_OR exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp L_OR exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production binExp -> exp L_OR exp - -State 146: -## Known stack suffix: -## exp L_AND -## LR(1) items: -binExp -> exp L_AND . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 147 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 147: -## Known stack suffix: -## exp L_AND exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp L_AND exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production binExp -> exp L_AND exp - -State 148: -## Known stack suffix: -## exp QUESTION -## LR(1) items: -exp -> exp QUESTION . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On OPEN_CURLY shift to state 149 -## Reductions: - -State 149: -## Known stack suffix: -## exp QUESTION OPEN_CURLY -## LR(1) items: -exp -> exp QUESTION OPEN_CURLY . typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 150 --- On sumTyp shift to state 33 -## Reductions: - -State 150: -## Known stack suffix: -## exp QUESTION OPEN_CURLY typ -## LR(1) items: -exp -> exp QUESTION OPEN_CURLY typ . EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] -## Transitions: --- On EQUAL_ARROW shift to state 151 --- On DASH_ARROW shift to state 31 -## Reductions: - -State 151: -## Known stack suffix: -## exp QUESTION OPEN_CURLY typ EQUAL_ARROW -## LR(1) items: -exp -> exp QUESTION OPEN_CURLY typ EQUAL_ARROW . typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 152 --- On sumTyp shift to state 33 -## Reductions: - -State 152: -## Known stack suffix: -## exp QUESTION OPEN_CURLY typ EQUAL_ARROW typ -## LR(1) items: -exp -> exp QUESTION OPEN_CURLY typ EQUAL_ARROW typ . CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ DASH_ARROW CLOSE_CURLY ] -## Transitions: --- On DASH_ARROW shift to state 31 --- On CLOSE_CURLY shift to state 153 -## Reductions: - -State 153: -## Known stack suffix: -## exp QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY -## LR(1) items: -exp -> exp QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> exp QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY - -State 154: -## Known stack suffix: -## exp POWER_FLOAT -## LR(1) items: -binExp -> exp POWER_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 155 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 155: -## Known stack suffix: -## exp POWER_FLOAT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp POWER_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp POWER_FLOAT exp - -State 156: -## Known stack suffix: -## exp OPEN_PAREN -## LR(1) items: -exp -> exp OPEN_PAREN . exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 157 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 157: -## Known stack suffix: -## exp OPEN_PAREN exp -## LR(1) items: -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp OPEN_PAREN exp . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On CLOSE_PAREN shift to state 210 --- On AT_SYMBOL shift to state 173 -## Reductions: - -State 158: -## Known stack suffix: -## exp TIMES -## LR(1) items: -binExp -> exp TIMES . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 159 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 159: -## Known stack suffix: -## exp TIMES exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp TIMES exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp TIMES exp - -State 160: -## Known stack suffix: -## exp POWER -## LR(1) items: -binExp -> exp POWER . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 161 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 161: -## Known stack suffix: -## exp POWER exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp POWER exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp POWER exp - -State 162: -## Known stack suffix: -## exp PLUS_FLOAT -## LR(1) items: -binExp -> exp PLUS_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 163 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 163: -## Known stack suffix: -## exp PLUS_FLOAT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp PLUS_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp PLUS_FLOAT exp - -State 164: -## Known stack suffix: -## exp OPEN_CURLY -## LR(1) items: -exp -> exp OPEN_CURLY . typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 165 --- On sumTyp shift to state 33 -## Reductions: - -State 165: -## Known stack suffix: -## exp OPEN_CURLY typ -## LR(1) items: -exp -> exp OPEN_CURLY typ . EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ EQUAL_ARROW DASH_ARROW ] -## Transitions: --- On EQUAL_ARROW shift to state 166 --- On DASH_ARROW shift to state 31 -## Reductions: - -State 166: -## Known stack suffix: -## exp OPEN_CURLY typ EQUAL_ARROW -## LR(1) items: -exp -> exp OPEN_CURLY typ EQUAL_ARROW . typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 167 --- On sumTyp shift to state 33 -## Reductions: - -State 167: -## Known stack suffix: -## exp OPEN_CURLY typ EQUAL_ARROW typ -## LR(1) items: -exp -> exp OPEN_CURLY typ EQUAL_ARROW typ . CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ DASH_ARROW CLOSE_CURLY ] -## Transitions: --- On DASH_ARROW shift to state 31 --- On CLOSE_CURLY shift to state 168 -## Reductions: - -State 168: -## Known stack suffix: -## exp OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY -## LR(1) items: -exp -> exp OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> exp OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY - -State 169: -## Known stack suffix: -## exp DIVIDE_FLOAT -## LR(1) items: -binExp -> exp DIVIDE_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 170 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 170: -## Known stack suffix: -## exp DIVIDE_FLOAT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp DIVIDE_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp DIVIDE_FLOAT exp - -State 171: -## Known stack suffix: -## exp CONS -## LR(1) items: -exp -> exp CONS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 172 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 172: -## Known stack suffix: -## exp CONS exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp CONS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On OPEN_PAREN shift to state 156 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> exp CONS exp - -State 173: -## Known stack suffix: -## exp AT_SYMBOL -## LR(1) items: -exp -> exp AT_SYMBOL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp AT_SYMBOL . LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 174 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 177 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 174: -## Known stack suffix: -## exp AT_SYMBOL LESS_THAN -## LR(1) items: -exp -> exp AT_SYMBOL LESS_THAN . typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> LESS_THAN . LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On UNKNOWN shift to state 14 --- On UNIT shift to state 16 --- On STRING_TYPE shift to state 17 --- On QUESTION shift to state 18 --- On PLUS shift to state 21 --- On OPEN_SQUARE_BRACKET shift to state 24 --- On OPEN_PAREN shift to state 25 --- On LESS_THAN shift to state 107 --- On INT_TYPE shift to state 26 --- On FLOAT_TYPE shift to state 27 --- On CONSTRUCTOR_IDENT shift to state 28 --- On BOOL_TYPE shift to state 29 --- On typ shift to state 175 --- On sumTyp shift to state 33 -## Reductions: - -State 175: -## Known stack suffix: -## exp AT_SYMBOL LESS_THAN typ -## LR(1) items: -exp -> exp AT_SYMBOL LESS_THAN typ . GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -typ -> typ . DASH_ARROW typ [ GREATER_THAN DASH_ARROW ] -## Transitions: --- On GREATER_THAN shift to state 176 --- On DASH_ARROW shift to state 31 -## Reductions: - -State 176: -## Known stack suffix: -## exp AT_SYMBOL LESS_THAN typ GREATER_THAN -## LR(1) items: -exp -> exp AT_SYMBOL LESS_THAN typ GREATER_THAN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> exp AT_SYMBOL LESS_THAN typ GREATER_THAN - -State 177: -## Known stack suffix: -## exp AT_SYMBOL exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp AT_SYMBOL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On L_OR shift to state 144 --- On L_AND shift to state 146 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> exp AT_SYMBOL exp - -State 178: -## Known stack suffix: -## exp NOT_EQUAL_FLOAT -## LR(1) items: -binExp -> exp NOT_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 179 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 179: -## Known stack suffix: -## exp NOT_EQUAL_FLOAT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp NOT_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp NOT_EQUAL_FLOAT exp - -State 180: -## Known stack suffix: -## exp MINUS_FLOAT -## LR(1) items: -binExp -> exp MINUS_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 181 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 181: -## Known stack suffix: -## exp MINUS_FLOAT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp MINUS_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS_FLOAT PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp MINUS_FLOAT exp - -State 182: -## Known stack suffix: -## exp LESS_THAN_FLOAT -## LR(1) items: -binExp -> exp LESS_THAN_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 183 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 183: -## Known stack suffix: -## exp LESS_THAN_FLOAT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp LESS_THAN_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp LESS_THAN_FLOAT exp - -State 184: -## Known stack suffix: -## exp LESS_THAN_EQUAL_FLOAT -## LR(1) items: -binExp -> exp LESS_THAN_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 185 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 185: -## Known stack suffix: -## exp LESS_THAN_EQUAL_FLOAT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp LESS_THAN_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp LESS_THAN_EQUAL_FLOAT exp - -State 186: -## Known stack suffix: -## exp LESS_THAN -## LR(1) items: -binExp -> exp LESS_THAN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 187 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 187: -## Known stack suffix: -## exp LESS_THAN exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp LESS_THAN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp LESS_THAN exp - -State 188: -## Known stack suffix: -## exp GREATER_THAN_FLOAT -## LR(1) items: -binExp -> exp GREATER_THAN_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 189 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 189: -## Known stack suffix: -## exp GREATER_THAN_FLOAT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp GREATER_THAN_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp GREATER_THAN_FLOAT exp - -State 190: -## Known stack suffix: -## exp GREATER_THAN_EQUAL_FLOAT -## LR(1) items: -binExp -> exp GREATER_THAN_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 191 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 191: -## Known stack suffix: -## exp GREATER_THAN_EQUAL_FLOAT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp GREATER_THAN_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp GREATER_THAN_EQUAL_FLOAT exp - -State 192: -## Known stack suffix: -## exp DOUBLE_EQUAL_FLOAT -## LR(1) items: -binExp -> exp DOUBLE_EQUAL_FLOAT . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 193 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 193: -## Known stack suffix: -## exp DOUBLE_EQUAL_FLOAT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp DOUBLE_EQUAL_FLOAT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL_FLOAT NOT_EQUAL MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp DOUBLE_EQUAL_FLOAT exp - -State 194: -## Known stack suffix: -## exp GREATER_THAN -## LR(1) items: -binExp -> exp GREATER_THAN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 195 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 195: -## Known stack suffix: -## exp GREATER_THAN exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp GREATER_THAN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DIVIDE_FLOAT shift to state 169 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE TIMES THEN POWER PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL DIVIDE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp GREATER_THAN exp - -State 196: -## Known stack suffix: -## exp DIVIDE -## LR(1) items: -binExp -> exp DIVIDE . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 197 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 197: -## Known stack suffix: -## exp DIVIDE exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp DIVIDE exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp DIVIDE exp - -State 198: -## Known stack suffix: -## exp PLUS -## LR(1) items: -binExp -> exp PLUS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 199 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 199: -## Known stack suffix: -## exp PLUS exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp PLUS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp PLUS exp - -State 200: -## Known stack suffix: -## exp NOT_EQUAL -## LR(1) items: -binExp -> exp NOT_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 201 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 201: -## Known stack suffix: -## exp NOT_EQUAL exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp NOT_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN NOT_EQUAL LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp NOT_EQUAL exp - -State 202: -## Known stack suffix: -## exp MINUS -## LR(1) items: -binExp -> exp MINUS . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 203 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 203: -## Known stack suffix: -## exp MINUS exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp MINUS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp MINUS exp - -State 204: -## Known stack suffix: -## exp LESS_THAN_EQUAL -## LR(1) items: -binExp -> exp LESS_THAN_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 205 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 205: -## Known stack suffix: -## exp LESS_THAN_EQUAL exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp LESS_THAN_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN NOT_EQUAL LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp LESS_THAN_EQUAL exp - -State 206: -## Known stack suffix: -## exp GREATER_THAN_EQUAL -## LR(1) items: -binExp -> exp GREATER_THAN_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 207 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 207: -## Known stack suffix: -## exp GREATER_THAN_EQUAL exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp GREATER_THAN_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN NOT_EQUAL LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp GREATER_THAN_EQUAL exp - -State 208: -## Known stack suffix: -## exp DOUBLE_EQUAL -## LR(1) items: -binExp -> exp DOUBLE_EQUAL . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 209 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 209: -## Known stack suffix: -## exp DOUBLE_EQUAL exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp DOUBLE_EQUAL exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN NOT_EQUAL LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production binExp -> exp DOUBLE_EQUAL exp - -State 210: -## Known stack suffix: -## exp OPEN_PAREN exp CLOSE_PAREN -## LR(1) items: -exp -> exp OPEN_PAREN exp CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> exp OPEN_PAREN exp CLOSE_PAREN - -State 211: -## Known stack suffix: -## filterAction exp IN -## LR(1) items: -exp -> filterAction exp IN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 212 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 212: -## Known stack suffix: -## filterAction exp IN exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> filterAction exp IN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On L_OR shift to state 144 --- On L_AND shift to state 146 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> filterAction exp IN exp - -State 213: -## Known stack suffix: -## CASE exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -case -> CASE exp . list(rul) END [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -## Transitions: --- On TURNSTILE shift to state 214 --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 --- On rul shift to state 218 --- On list(rul) shift to state 220 -## Reductions: --- On END --- reduce production list(rul) -> - -State 214: -## Known stack suffix: -## TURNSTILE -## LR(1) items: -rul -> TURNSTILE . pat EQUAL_ARROW exp [ TURNSTILE END ] -## Transitions: --- On WILD shift to state 61 --- On TRUE shift to state 62 --- On STRING shift to state 63 --- On QUESTION shift to state 64 --- On OPEN_SQUARE_BRACKET shift to state 67 --- On OPEN_PAREN shift to state 68 --- On INT shift to state 69 --- On IDENT shift to state 70 --- On FLOAT shift to state 71 --- On FALSE shift to state 72 --- On CONSTRUCTOR_IDENT shift to state 73 --- On pat shift to state 215 -## Reductions: - -State 215: -## Known stack suffix: -## TURNSTILE pat -## LR(1) items: -pat -> pat . COLON typ [ OPEN_PAREN OPEN_CURLY EQUAL_ARROW CONS COLON ] -pat -> pat . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ OPEN_PAREN OPEN_CURLY EQUAL_ARROW CONS COLON ] -pat -> pat . CONS pat [ OPEN_PAREN OPEN_CURLY EQUAL_ARROW CONS COLON ] -pat -> pat . OPEN_PAREN pat CLOSE_PAREN [ OPEN_PAREN OPEN_CURLY EQUAL_ARROW CONS COLON ] -rul -> TURNSTILE pat . EQUAL_ARROW exp [ TURNSTILE END ] -## Transitions: --- On OPEN_PAREN shift to state 77 --- On OPEN_CURLY shift to state 79 --- On EQUAL_ARROW shift to state 216 --- On CONS shift to state 84 --- On COLON shift to state 86 -## Reductions: - -State 216: -## Known stack suffix: -## TURNSTILE pat EQUAL_ARROW -## LR(1) items: -rul -> TURNSTILE pat EQUAL_ARROW . exp [ TURNSTILE END ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 217 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 217: -## Known stack suffix: -## TURNSTILE pat EQUAL_ARROW exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -rul -> TURNSTILE pat EQUAL_ARROW exp . [ TURNSTILE END ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE END --- reduce production rul -> TURNSTILE pat EQUAL_ARROW exp - -State 218: -## Known stack suffix: -## rul -## LR(1) items: -list(rul) -> rul . list(rul) [ END ] -## Transitions: --- On TURNSTILE shift to state 214 --- On rul shift to state 218 --- On list(rul) shift to state 219 -## Reductions: --- On END --- reduce production list(rul) -> - -State 219: -## Known stack suffix: -## rul list(rul) -## LR(1) items: -list(rul) -> rul list(rul) . [ END ] -## Transitions: -## Reductions: --- On END --- reduce production list(rul) -> rul list(rul) - -State 220: -## Known stack suffix: -## CASE exp list(rul) -## LR(1) items: -case -> CASE exp list(rul) . END [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On END shift to state 221 -## Reductions: - -State 221: -## Known stack suffix: -## CASE exp list(rul) END -## LR(1) items: -case -> CASE exp list(rul) END . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production case -> CASE exp list(rul) END - -State 222: -## Known stack suffix: -## DOLLAR_SIGN exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -unExp -> DOLLAR_SIGN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On L_OR shift to state 144 --- On L_AND shift to state 146 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production unExp -> DOLLAR_SIGN exp - -State 223: -## Known stack suffix: -## FIX pat DASH_ARROW exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> FIX pat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> FIX pat DASH_ARROW exp - -State 224: -## Known stack suffix: -## FUN pat DASH_ARROW exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -funExp -> FUN pat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production funExp -> FUN pat DASH_ARROW exp - -State 225: -## Known stack suffix: -## IF exp -## LR(1) items: -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> IF exp . THEN exp ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On THEN shift to state 226 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: - -State 226: -## Known stack suffix: -## IF exp THEN -## LR(1) items: -exp -> IF exp THEN . exp ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 227 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 227: -## Known stack suffix: -## IF exp THEN exp -## LR(1) items: -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> IF exp THEN exp . ELSE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On ELSE shift to state 228 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: - -State 228: -## Known stack suffix: -## IF exp THEN exp ELSE -## LR(1) items: -exp -> IF exp THEN exp ELSE . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 229 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 229: -## Known stack suffix: -## IF exp THEN exp ELSE exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> IF exp THEN exp ELSE exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> IF exp THEN exp ELSE exp - -State 230: -## Known stack suffix: -## LESS_THAN LESS_THAN exp -## LR(1) items: -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> LESS_THAN LESS_THAN exp . QUESTION SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 231 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: - -State 231: -## Known stack suffix: -## LESS_THAN LESS_THAN exp QUESTION -## LR(1) items: -exp -> exp QUESTION . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> LESS_THAN LESS_THAN exp QUESTION . SEXP_STRING GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On SEXP_STRING shift to state 232 --- On OPEN_CURLY shift to state 149 -## Reductions: - -State 232: -## Known stack suffix: -## LESS_THAN LESS_THAN exp QUESTION SEXP_STRING -## LR(1) items: -exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING . GREATER_THAN GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On GREATER_THAN shift to state 233 -## Reductions: - -State 233: -## Known stack suffix: -## LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN -## LR(1) items: -exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN . GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On GREATER_THAN shift to state 234 -## Reductions: - -State 234: -## Known stack suffix: -## LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN -## LR(1) items: -exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> LESS_THAN LESS_THAN exp QUESTION SEXP_STRING GREATER_THAN GREATER_THAN - -State 235: -## Known stack suffix: -## LET pat SINGLE_EQUAL exp -## LR(1) items: -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> LET pat SINGLE_EQUAL exp . IN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On IN shift to state 236 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: - -State 236: -## Known stack suffix: -## LET pat SINGLE_EQUAL exp IN -## LR(1) items: -exp -> LET pat SINGLE_EQUAL exp IN . exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 237 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 237: -## Known stack suffix: -## LET pat SINGLE_EQUAL exp IN exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> LET pat SINGLE_EQUAL exp IN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> LET pat SINGLE_EQUAL exp IN exp - -State 238: -## Known stack suffix: -## L_NOT exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -unExp -> L_NOT exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production unExp -> L_NOT exp - -State 239: -## Known stack suffix: -## MINUS exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -unExp -> MINUS exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On MINUS_FLOAT shift to state 180 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN PLUS NOT_EQUAL MINUS LESS_THAN_EQUAL IN GREATER_THAN_EQUAL EOF END ELSE DOUBLE_EQUAL COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production unExp -> MINUS exp - -State 240: -## Known stack suffix: -## NAMED_FUN IDENT pat DASH_ARROW exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -funExp -> NAMED_FUN IDENT pat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production funExp -> NAMED_FUN IDENT pat DASH_ARROW exp - -State 241: -## Known stack suffix: -## OPEN_PAREN exp -## LR(1) items: -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> OPEN_PAREN exp . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> OPEN_PAREN exp . COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On COMMA shift to state 242 --- On CLOSE_PAREN shift to state 249 --- On AT_SYMBOL shift to state 173 -## Reductions: - -State 242: -## Known stack suffix: -## OPEN_PAREN exp COMMA -## LR(1) items: -exp -> OPEN_PAREN exp COMMA . loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On separated_nonempty_list(COMMA,exp) shift to state 243 --- On loption(separated_nonempty_list(COMMA,exp)) shift to state 244 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 246 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: --- On CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,exp)) -> - -State 243: -## Known stack suffix: -## separated_nonempty_list(COMMA,exp) -## LR(1) items: -loption(separated_nonempty_list(COMMA,exp)) -> separated_nonempty_list(COMMA,exp) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production loption(separated_nonempty_list(COMMA,exp)) -> separated_nonempty_list(COMMA,exp) - -State 244: -## Known stack suffix: -## OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) -## LR(1) items: -exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) . CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On CLOSE_PAREN shift to state 245 -## Reductions: - -State 245: -## Known stack suffix: -## OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN -## LR(1) items: -exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> OPEN_PAREN exp COMMA loption(separated_nonempty_list(COMMA,exp)) CLOSE_PAREN - -State 246: -## Known stack suffix: -## exp -## LR(1) items: -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -separated_nonempty_list(COMMA,exp) -> exp . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -separated_nonempty_list(COMMA,exp) -> exp . COMMA separated_nonempty_list(COMMA,exp) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On COMMA shift to state 247 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,exp) -> exp - -State 247: -## Known stack suffix: -## exp COMMA -## LR(1) items: -separated_nonempty_list(COMMA,exp) -> exp COMMA . separated_nonempty_list(COMMA,exp) [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: --- On WILD shift to state 1 --- On UNDEF shift to state 2 --- On TYP_FUN shift to state 3 --- On TYP shift to state 11 --- On TRUE shift to state 50 --- On TEST shift to state 51 --- On STRING shift to state 52 --- On QUESTION shift to state 53 --- On PAUSE shift to state 56 --- On OPEN_SQUARE_BRACKET shift to state 57 --- On OPEN_PAREN shift to state 58 --- On NAMED_FUN shift to state 59 --- On MINUS shift to state 101 --- On L_NOT shift to state 102 --- On LET shift to state 103 --- On LESS_THAN shift to state 106 --- On INT shift to state 108 --- On IF shift to state 109 --- On IDENT shift to state 110 --- On HIDE shift to state 111 --- On FUN shift to state 112 --- On FLOAT shift to state 115 --- On FIX shift to state 116 --- On FALSE shift to state 119 --- On EVAL shift to state 120 --- On DOLLAR_SIGN shift to state 121 --- On DEBUG shift to state 122 --- On CONSTRUCTOR_IDENT shift to state 123 --- On CASE shift to state 128 --- On BUILTIN shift to state 129 --- On unExp shift to state 130 --- On separated_nonempty_list(COMMA,exp) shift to state 248 --- On funExp shift to state 131 --- On filterAction shift to state 132 --- On exp shift to state 246 --- On case shift to state 138 --- On binExp shift to state 139 -## Reductions: - -State 248: -## Known stack suffix: -## exp COMMA separated_nonempty_list(COMMA,exp) -## LR(1) items: -separated_nonempty_list(COMMA,exp) -> exp COMMA separated_nonempty_list(COMMA,exp) . [ CLOSE_SQUARE_BRACKET CLOSE_PAREN ] -## Transitions: -## Reductions: --- On CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production separated_nonempty_list(COMMA,exp) -> exp COMMA separated_nonempty_list(COMMA,exp) - -State 249: -## Known stack suffix: -## OPEN_PAREN exp CLOSE_PAREN -## LR(1) items: -exp -> OPEN_PAREN exp CLOSE_PAREN . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> OPEN_PAREN exp CLOSE_PAREN - -State 250: -## Known stack suffix: -## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) -## LR(1) items: -exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) . CLOSE_SQUARE_BRACKET [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On CLOSE_SQUARE_BRACKET shift to state 251 -## Reductions: - -State 251: -## Known stack suffix: -## OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET -## LR(1) items: -exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> OPEN_SQUARE_BRACKET loption(separated_nonempty_list(COMMA,exp)) CLOSE_SQUARE_BRACKET - -State 252: -## Known stack suffix: -## TEST exp -## LR(1) items: -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> TEST exp . END [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN END DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On END shift to state 253 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: - -State 253: -## Known stack suffix: -## TEST exp END -## LR(1) items: -exp -> TEST exp END . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> TEST exp END - -State 254: -## Known stack suffix: -## TYP tpat SINGLE_EQUAL typ IN exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> TYP tpat SINGLE_EQUAL typ IN exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On L_OR shift to state 144 --- On L_AND shift to state 146 -## Reductions: --- On TURNSTILE TIMES_FLOAT TIMES THEN SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL --- reduce production exp -> TYP tpat SINGLE_EQUAL typ IN exp - -State 255: -## Known stack suffix: -## TYP_FUN tpat DASH_ARROW exp -## LR(1) items: -binExp -> exp . MINUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_AND exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . L_OR exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> TYP_FUN tpat DASH_ARROW exp . [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . CONS exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TURNSTILE TIMES_FLOAT TIMES THEN STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN IN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF END ELSE DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN AT_SYMBOL ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: --- On TURNSTILE THEN IN EOF END ELSE COMMA CLOSE_SQUARE_BRACKET CLOSE_PAREN --- reduce production exp -> TYP_FUN tpat DASH_ARROW exp - -State 256: -## Known stack suffix: -## program -## LR(1) items: -program' -> program . [ # ] -## Transitions: -## Reductions: --- On # --- accept program - -State 257: -## Known stack suffix: -## exp -## LR(1) items: -binExp -> exp . MINUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . PLUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . MINUS_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . TIMES_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . POWER_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DIVIDE_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . DOUBLE_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . NOT_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . LESS_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . GREATER_THAN_EQUAL_FLOAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_AND exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . L_OR exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_CONCAT exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -binExp -> exp . STRING_EQUAL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_PAREN exp CLOSE_PAREN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . QUESTION OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . OPEN_CURLY typ EQUAL_ARROW typ CLOSE_CURLY [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . CONS exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . SEMI_COLON exp [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -exp -> exp . AT_SYMBOL LESS_THAN typ GREATER_THAN [ TIMES_FLOAT TIMES STRING_EQUAL STRING_CONCAT SEMI_COLON QUESTION POWER_FLOAT POWER PLUS_FLOAT PLUS OPEN_PAREN OPEN_CURLY NOT_EQUAL_FLOAT NOT_EQUAL MINUS_FLOAT MINUS L_OR L_AND LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT LESS_THAN_EQUAL LESS_THAN GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT GREATER_THAN_EQUAL GREATER_THAN EOF DOUBLE_EQUAL_FLOAT DOUBLE_EQUAL DIVIDE_FLOAT DIVIDE CONS AT_SYMBOL ] -program -> exp . EOF [ # ] -## Transitions: --- On TIMES_FLOAT shift to state 134 --- On TIMES shift to state 158 --- On STRING_EQUAL shift to state 136 --- On STRING_CONCAT shift to state 140 --- On SEMI_COLON shift to state 142 --- On QUESTION shift to state 148 --- On POWER_FLOAT shift to state 154 --- On POWER shift to state 160 --- On PLUS_FLOAT shift to state 162 --- On PLUS shift to state 198 --- On OPEN_PAREN shift to state 156 --- On OPEN_CURLY shift to state 164 --- On NOT_EQUAL_FLOAT shift to state 178 --- On NOT_EQUAL shift to state 200 --- On MINUS_FLOAT shift to state 180 --- On MINUS shift to state 202 --- On L_OR shift to state 144 --- On L_AND shift to state 146 --- On LESS_THAN_FLOAT shift to state 182 --- On LESS_THAN_EQUAL_FLOAT shift to state 184 --- On LESS_THAN_EQUAL shift to state 204 --- On LESS_THAN shift to state 186 --- On GREATER_THAN_FLOAT shift to state 188 --- On GREATER_THAN_EQUAL_FLOAT shift to state 190 --- On GREATER_THAN_EQUAL shift to state 206 --- On GREATER_THAN shift to state 194 --- On EOF shift to state 258 --- On DOUBLE_EQUAL_FLOAT shift to state 192 --- On DOUBLE_EQUAL shift to state 208 --- On DIVIDE_FLOAT shift to state 169 --- On DIVIDE shift to state 196 --- On CONS shift to state 171 --- On AT_SYMBOL shift to state 173 -## Reductions: - -State 258: -## Known stack suffix: -## exp EOF -## LR(1) items: -program -> exp EOF . [ # ] -## Transitions: -## Reductions: --- On # --- reduce production program -> exp EOF - diff --git a/src/haz3lmenhir/Parser.conflicts b/src/haz3lmenhir/Parser.conflicts deleted file mode 100644 index e191b7946a..0000000000 --- a/src/haz3lmenhir/Parser.conflicts +++ /dev/null @@ -1,28 +0,0 @@ - -** Conflict (shift/reduce) in state 41. -** Token involved: CLOSE_PAREN -** This state is reached from program after reading: - -CONSTRUCTOR_IDENT TILDE PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ - -** The derivations that appear below have the following common factor: -** (The question mark symbol (?) represents the spot where the derivations begin to differ.) - -program -exp EOF -CONSTRUCTOR_IDENT TILDE typ - sumTyp - (?) - -** In state 41, looking ahead at CLOSE_PAREN, reducing production -** separated_nonempty_list(COMMA,typ) -> typ -** is permitted because of the following sub-derivation: - -PLUS CONSTRUCTOR_IDENT OPEN_PAREN loption(separated_nonempty_list(COMMA,typ)) CLOSE_PAREN // lookahead token appears - separated_nonempty_list(COMMA,typ) // lookahead token is inherited - typ . - -** In state 41, looking ahead at CLOSE_PAREN, shifting is permitted -** because of the following sub-derivation: - -PLUS CONSTRUCTOR_IDENT OPEN_PAREN typ . CLOSE_PAREN From 497ea3f7ccb8b835b929f5a95edb4a1e7ed797e4 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 2 Dec 2024 13:04:29 -0500 Subject: [PATCH 097/281] Make tests for every documentation buffer --- test/Test_Menhir.re | 550 ++++++++++++++++++++++---------------------- 1 file changed, 275 insertions(+), 275 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index a0025c3437..f41d13b90b 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -192,297 +192,298 @@ let single_integer_menhir = () => single_int_str, ); -let tests = [ - parser_test("Integer Literal", Int(8) |> Exp.fresh, "8"), - parser_test("Fun", fun_exp, "fun x -> x"), - parser_test( - "String Literal", - String("Hello World") |> Exp.fresh, - "\"Hello World\"", - ), - parser_test("Bool Literal", Bool(true) |> Exp.fresh, "true"), - parser_test("Empty Hole", EmptyHole |> Exp.fresh, "?"), - parser_test("Var", Var("x") |> Exp.fresh, "x"), - parser_test("Parens", Parens(Var("y") |> Exp.fresh) |> Exp.fresh, "(y)"), - parser_test( - "BinOp", - BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) |> Exp.fresh, - "4 + 5", - ), - parser_test( - "Let", - Let(Var("x") |> Pat.fresh, Int(5) |> Exp.fresh, Var("x") |> Exp.fresh) - |> Exp.fresh, - "let x = 5 in x", - ), - parser_test( - "Tuple", - Tuple([Int(4) |> Exp.fresh, Int(5) |> Exp.fresh]) |> Exp.fresh, - "(4, 5)" // TODO Verify with maketerm. Should this be parens or not - ), - parser_test( - "Match", - Match( - Int(4) |> Exp.fresh, - [ - (Int(1) |> Pat.fresh, String("hello") |> Exp.fresh), - (Wild |> Pat.fresh, String("world") |> Exp.fresh), - ], - ) - |> Exp.fresh, - {|case 4 +let tests = + [ + parser_test("Integer Literal", Int(8) |> Exp.fresh, "8"), + parser_test("Fun", fun_exp, "fun x -> x"), + parser_test( + "String Literal", + String("Hello World") |> Exp.fresh, + "\"Hello World\"", + ), + parser_test("Bool Literal", Bool(true) |> Exp.fresh, "true"), + parser_test("Empty Hole", EmptyHole |> Exp.fresh, "?"), + parser_test("Var", Var("x") |> Exp.fresh, "x"), + parser_test( + "Parens", + Parens(Var("y") |> Exp.fresh) |> Exp.fresh, + "(y)", + ), + parser_test( + "BinOp", + BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) + |> Exp.fresh, + "4 + 5", + ), + parser_test( + "Let", + Let( + Var("x") |> Pat.fresh, + Int(5) |> Exp.fresh, + Var("x") |> Exp.fresh, + ) + |> Exp.fresh, + "let x = 5 in x", + ), + parser_test( + "Tuple", + Tuple([Int(4) |> Exp.fresh, Int(5) |> Exp.fresh]) |> Exp.fresh, + "(4, 5)" // TODO Verify with maketerm. Should this be parens or not + ), + parser_test( + "Match", + Match( + Int(4) |> Exp.fresh, + [ + (Int(1) |> Pat.fresh, String("hello") |> Exp.fresh), + (Wild |> Pat.fresh, String("world") |> Exp.fresh), + ], + ) + |> Exp.fresh, + {|case 4 | 1 => "hello" | _ => "world" end|}, - ), - parser_test( - "If", - If(Bool(true) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) - |> Exp.fresh, - "if true then 8 else 6", - ), - parser_test( - "Deferred Ap", - DeferredAp(Var("x") |> Exp.fresh, [Deferral(InAp) |> Exp.fresh]) - |> Exp.fresh, - "x(_)", - ), - parser_test( - "Cons", - Cons(Int(1) |> Exp.fresh, ListLit([]) |> Exp.fresh) |> Exp.fresh, - "1 :: []", - ), - parser_test( - "ListLit", - ListLit([ - Int(1) |> Exp.fresh, - Int(2) |> Exp.fresh, - Int(3) |> Exp.fresh, - ]) - |> Exp.fresh, - "[1, 2, 3]", - ), - menhir_only_test( - "Constructor", - Constructor("A", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, - "A", - ), - menhir_only_test( - "Constructor cast", - Cast( + ), + parser_test( + "If", + If(Bool(true) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) + |> Exp.fresh, + "if true then 8 else 6", + ), + parser_test( + "Deferred Ap", + DeferredAp(Var("x") |> Exp.fresh, [Deferral(InAp) |> Exp.fresh]) + |> Exp.fresh, + "x(_)", + ), + parser_test( + "Cons", + Cons(Int(1) |> Exp.fresh, ListLit([]) |> Exp.fresh) |> Exp.fresh, + "1 :: []", + ), + parser_test( + "ListLit", + ListLit([ + Int(1) |> Exp.fresh, + Int(2) |> Exp.fresh, + Int(3) |> Exp.fresh, + ]) + |> Exp.fresh, + "[1, 2, 3]", + ), + menhir_only_test( + "Constructor", Constructor("A", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, - Unknown(Internal) |> Typ.fresh, - Int |> Typ.fresh, - ) - |> Exp.fresh, - "A : Int", - ), - menhir_only_test( - "Constructor of specific sum type", - Constructor("A", Int |> Typ.fresh) |> Exp.fresh, - "A ~ Int", - ), - // TODO Fix for the tests below - menhir_only_test( - "Constructor with Type Variable", - Constructor("A", Var("T") |> Typ.fresh) |> Exp.fresh, - "A ~ T", - ), - parser_test( - "Type Variable", - Let( + "A", + ), + menhir_only_test( + "Constructor cast", Cast( - Var("x") |> Pat.fresh, - Var("T") |> Typ.fresh, + Constructor("A", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, Unknown(Internal) |> Typ.fresh, + Int |> Typ.fresh, ) - |> Pat.fresh, - EmptyHole |> Exp.fresh, - Var("x") |> Exp.fresh, - ) - |> Exp.fresh, - "let x : T = ? in x", - ), - parser_test( - "Type Alias", - TyAlias(Var("x") |> TPat.fresh, Int |> Typ.fresh, Int(1) |> Exp.fresh) - |> Exp.fresh, - "type x = Int in 1", - ), - parser_test( - "Test", - Test( - BinOp(Int(Equals), Int(3) |> Exp.fresh, Int(3) |> Exp.fresh) |> Exp.fresh, - ) - |> Exp.fresh, - "test 3 == 3 end", - ), - parser_test( - "Filter", - Filter( - Filter({act: (Eval, All), pat: Int(3) |> Exp.fresh}), - Int(3) |> Exp.fresh, - ) - |> Exp.fresh, - "eval 3 in 3" // TODO Use other filter commands - ), - parser_test( - "List Concat", - ListConcat( - ListLit([Int(1) |> Exp.fresh, Int(2) |> Exp.fresh]) |> Exp.fresh, - ListLit([Int(3) |> Exp.fresh, Int(4) |> Exp.fresh]) |> Exp.fresh, - ) - |> Exp.fresh, - "[1, 2] @ [3, 4]", - ), - parser_test( - "times and divide precendence", - BinOp( - Int(Times), - Int(1) |> Exp.fresh, - BinOp(Int(Divide), Int(2) |> Exp.fresh, Int(3) |> Exp.fresh) + "A : Int", + ), + menhir_only_test( + "Constructor of specific sum type", + Constructor("A", Int |> Typ.fresh) |> Exp.fresh, + "A ~ Int", + ), + // TODO Fix for the tests below + menhir_only_test( + "Constructor with Type Variable", + Constructor("A", Var("T") |> Typ.fresh) |> Exp.fresh, + "A ~ T", + ), + parser_test( + "Type Variable", + Let( + Cast( + Var("x") |> Pat.fresh, + Var("T") |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Pat.fresh, + EmptyHole |> Exp.fresh, + Var("x") |> Exp.fresh, + ) |> Exp.fresh, - ) - |> Exp.fresh, - "1 * 2 / 3", - ), - parser_test( - "plus and minus precendence", - BinOp( - Int(Plus), - BinOp(Int(Minus), Int(1) |> Exp.fresh, Int(2) |> Exp.fresh) + "let x : T = ? in x", + ), + parser_test( + "Type Alias", + TyAlias(Var("x") |> TPat.fresh, Int |> Typ.fresh, Int(1) |> Exp.fresh) |> Exp.fresh, - Int(3) |> Exp.fresh, - ) - |> Exp.fresh, - "1 - 2 + 3", - ), - parser_test( - "Integer Ops", - BinOp( - Int(GreaterThanOrEqual), + "type x = Int in 1", + ), + parser_test( + "Test", + Test( + BinOp(Int(Equals), Int(3) |> Exp.fresh, Int(3) |> Exp.fresh) + |> Exp.fresh, + ) + |> Exp.fresh, + "test 3 == 3 end", + ), + parser_test( + "Filter", + Filter( + Filter({act: (Eval, All), pat: Int(3) |> Exp.fresh}), + Int(3) |> Exp.fresh, + ) + |> Exp.fresh, + "eval 3 in 3" // TODO Use other filter commands + ), + parser_test( + "List Concat", + ListConcat( + ListLit([Int(1) |> Exp.fresh, Int(2) |> Exp.fresh]) |> Exp.fresh, + ListLit([Int(3) |> Exp.fresh, Int(4) |> Exp.fresh]) |> Exp.fresh, + ) + |> Exp.fresh, + "[1, 2] @ [3, 4]", + ), + parser_test( + "times and divide precendence", BinOp( - Int(Minus), - BinOp( - Int(Plus), - UnOp(Int(Minus), Int(1) |> Exp.fresh) |> Exp.fresh, - Int(2) |> Exp.fresh, - ) + Int(Times), + Int(1) |> Exp.fresh, + BinOp(Int(Divide), Int(2) |> Exp.fresh, Int(3) |> Exp.fresh) + |> Exp.fresh, + ) + |> Exp.fresh, + "1 * 2 / 3", + ), + parser_test( + "plus and minus precendence", + BinOp( + Int(Plus), + BinOp(Int(Minus), Int(1) |> Exp.fresh, Int(2) |> Exp.fresh) |> Exp.fresh, + Int(3) |> Exp.fresh, + ) + |> Exp.fresh, + "1 - 2 + 3", + ), + parser_test( + "Integer Ops", + BinOp( + Int(GreaterThanOrEqual), BinOp( - Int(Divide), - Int(3) |> Exp.fresh, + Int(Minus), BinOp( - Int(Times), - Int(4) |> Exp.fresh, - BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) + Int(Plus), + UnOp(Int(Minus), Int(1) |> Exp.fresh) |> Exp.fresh, + Int(2) |> Exp.fresh, + ) + |> Exp.fresh, + BinOp( + Int(Divide), + Int(3) |> Exp.fresh, + BinOp( + Int(Times), + Int(4) |> Exp.fresh, + BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) + |> Exp.fresh, + ) |> Exp.fresh, ) |> Exp.fresh, ) |> Exp.fresh, + Int(8) |> Exp.fresh, ) |> Exp.fresh, - Int(8) |> Exp.fresh, - ) - |> Exp.fresh, - "-1 + 2 - 3 / 4 * 5 ** 6 >= 8", - ), - parser_test("Float", Float(1.) |> Exp.fresh, "1."), - parser_test( - "Float Ops", - BinOp( - Float(LessThan), + "-1 + 2 - 3 / 4 * 5 ** 6 >= 8", + ), + parser_test("Float", Float(1.) |> Exp.fresh, "1."), + parser_test( + "Float Ops", BinOp( - Float(Minus), - Float(2.) |> Exp.fresh, + Float(LessThan), BinOp( - Float(Divide), - Float(3.) |> Exp.fresh, + Float(Minus), + Float(2.) |> Exp.fresh, BinOp( - Float(Times), - Float(4.) |> Exp.fresh, + Float(Divide), + Float(3.) |> Exp.fresh, BinOp( - Float(Power), - Float(5.) |> Exp.fresh, - Float(6.) |> Exp.fresh, + Float(Times), + Float(4.) |> Exp.fresh, + BinOp( + Float(Power), + Float(5.) |> Exp.fresh, + Float(6.) |> Exp.fresh, + ) + |> Exp.fresh, ) |> Exp.fresh, ) |> Exp.fresh, ) |> Exp.fresh, + Float(8.) |> Exp.fresh, ) |> Exp.fresh, - Float(8.) |> Exp.fresh, - ) - |> Exp.fresh, - "2. -. 3. /. 4. *. 5. **. 6. <. 8.", - ), - parser_test( - "Let binding with type ascription", - Let( - Cast( - Var("x") |> Pat.fresh, - Int |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, + "2. -. 3. /. 4. *. 5. **. 6. <. 8.", + ), + parser_test( + "Let binding with type ascription", + Let( + Cast( + Var("x") |> Pat.fresh, + Int |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Pat.fresh, + Int(5) |> Exp.fresh, + Var("x") |> Exp.fresh, ) - |> Pat.fresh, - Int(5) |> Exp.fresh, - Var("x") |> Exp.fresh, - ) - |> Exp.fresh, - "let (x: Int) = 5 in x", - ), - menhir_only_test( - "named_function", - Fun( - Pat.Var("x") |> Pat.fresh, - BinOp(Int(Plus), Var("x") |> Exp.fresh, Int(5) |> Exp.fresh) |> Exp.fresh, - None, - Some("f"), - ) - |> Exp.fresh, - "named_fun f x -> x + 5", - ), - parser_test( - "basic sum type", - Let( - Cast( - Var("x") |> Pat.fresh, - Sum([ - Variant("A", [], None), - Variant("B", [], None), - Variant("C", [], Some(Int |> Typ.fresh)), - ]) - |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, + "let (x: Int) = 5 in x", + ), + menhir_only_test( + "named_function", + Fun( + Pat.Var("x") |> Pat.fresh, + BinOp(Int(Plus), Var("x") |> Exp.fresh, Int(5) |> Exp.fresh) + |> Exp.fresh, + None, + Some("f"), ) - |> Pat.fresh, - Ap( - Forward, - Constructor("C", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, - Int(7) |> Exp.fresh, + |> Exp.fresh, + "named_fun f x -> x + 5", + ), + parser_test( + "basic sum type", + Let( + Cast( + Var("x") |> Pat.fresh, + Sum([ + Variant("A", [], None), + Variant("B", [], None), + Variant("C", [], Some(Int |> Typ.fresh)), + ]) + |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Pat.fresh, + Ap( + Forward, + Constructor("C", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, + Int(7) |> Exp.fresh, + ) + |> Exp.fresh, + Var("x") |> Exp.fresh, ) |> Exp.fresh, - Var("x") |> Exp.fresh, - ) - |> Exp.fresh, - "let x : +A +B +C(Int) = C(7) in x", - ), - { - // parser_test( - // "Partial basic_reference test", - // Int(5) |> Exp.fresh, - // " - // let y : (Int, Int, Int) -> Int = - // fun (m, x, b) -> m * x + b in - // 1 - // ", - // ), - + "let x : +A +B +C(Int) = C(7) in x", + ), + ] + @ { let strip_comments = str => { let re = Str.regexp("#[^#]*#"); Str.global_replace(re, "", str); @@ -491,25 +492,24 @@ let tests = [ let re = Str.regexp("= in"); Str.global_replace(re, "= ? in", str); }; - - let basic_reference = - Haz3lweb.Init.startup.documentation - |> (((_, slides, _)) => slides) - |> List.assoc("Basic Reference") - |> (slide => strip_comments(slide.backup_text)) - |> replace_holes; - - print_endline(basic_reference); - - test_case("Basic Reference", `Quick, () => { - // let _ = Alcotest.skip(); - alco_check( - "Menhir parse does not match MakeTerm", - make_term_parse(basic_reference), - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(basic_reference), - ), - ) - }); - }, -]; + let (_, slides: list((string, PersistentZipper.t)), _) = + Haz3lweb.Init.startup.documentation; + let te = + List.map( + ((name, slide): (string, PersistentZipper.t)) => { + test_case("Documentation buffer: " ++ name, `Quick, () => { + alco_check( + "Menhir parse does not match MakeTerm", + make_term_parse(slide.backup_text), + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program( + replace_holes(strip_comments(slide.backup_text)), + ), + ), + ) + }) + }, + slides, + ); + te; + }; From a6f0f033146bd71d594901b2ac042d65cef45ff9 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 2 Dec 2024 13:06:18 -0500 Subject: [PATCH 098/281] Print doc buffer source text before test --- test/Test_Menhir.re | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index f41d13b90b..ce3aefe8d3 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -494,22 +494,25 @@ let tests = }; let (_, slides: list((string, PersistentZipper.t)), _) = Haz3lweb.Init.startup.documentation; - let te = - List.map( - ((name, slide): (string, PersistentZipper.t)) => { - test_case("Documentation buffer: " ++ name, `Quick, () => { + List.map( + ((name, slide): (string, PersistentZipper.t)) => { + test_case( + "Documentation buffer: " ++ name, + `Quick, + () => { + let cleaned_source = + replace_holes(strip_comments(slide.backup_text)); + print_endline(cleaned_source); alco_check( "Menhir parse does not match MakeTerm", make_term_parse(slide.backup_text), Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program( - replace_holes(strip_comments(slide.backup_text)), - ), + Haz3lmenhir.Interface.parse_program(cleaned_source), ), - ) - }) - }, - slides, - ); - te; - }; + ); + }, + ) + }, + slides, + ); + }; \ No newline at end of file From 3ea7cb5e495a040705aa8fab70dd544d3800902b Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 2 Dec 2024 13:26:52 -0500 Subject: [PATCH 099/281] Add test for empty type holes --- test/Test_Menhir.re | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index ce3aefe8d3..3e646afea5 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -482,6 +482,7 @@ let tests = |> Exp.fresh, "let x : +A +B +C(Int) = C(7) in x", ), + menhir_maketerm_equivalent_test("Empty Type Hole", "let g: ? = 7 in g"), ] @ { let strip_comments = str => { @@ -515,4 +516,4 @@ let tests = }, slides, ); - }; \ No newline at end of file + }; From 3b72ec293fdcf2d03af581d9d7b7ba692997f0f3 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 3 Dec 2024 11:08:00 -0500 Subject: [PATCH 100/281] Add EmptyHole type to menhir --- src/haz3lmenhir/AST.re | 3 ++- src/haz3lmenhir/Conversion.re | 1 + src/haz3lmenhir/Parser.mly | 1 + 3 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index c2d011a4f4..610d225301 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -72,7 +72,8 @@ type op_un = [@deriving (show({with_path: false}), sexp)] type typ_provenance = - | Internal; + | Internal + | EmptyHole; [@deriving (show({with_path: false}), sexp)] type typ = diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 43cf64787a..894849db76 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -238,6 +238,7 @@ and Typ: { | UnknownType(p) => switch (p) { | Internal => Unknown(Internal) + | EmptyHole => Unknown(Hole(EmptyHole)) } | TypVar(s) => Var(s) | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 6b92aa29bc..903a22cc73 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -226,6 +226,7 @@ typ: | BOOL_TYPE { BoolType } | STRING_TYPE { StringType } | UNKNOWN; INTERNAL { UnknownType(Internal) } + | QUESTION { UnknownType(EmptyHole) } | UNIT { UnitType } | t = tupleType { t } | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } From 66de4a3eacf8b937e980432d768a08dd31ee843c Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 3 Dec 2024 11:14:26 -0500 Subject: [PATCH 101/281] Added test --- test/Test_Menhir.re | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 3e646afea5..4535235911 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -483,6 +483,10 @@ let tests = "let x : +A +B +C(Int) = C(7) in x", ), menhir_maketerm_equivalent_test("Empty Type Hole", "let g: ? = 7 in g"), + menhir_maketerm_equivalent_test( + "Pattern with type ascription", + "fun b: Bool -> b", + ), ] @ { let strip_comments = str => { From 5d2c5e8f07e6f00963d29b2a7e7f66809660a181 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Wed, 4 Dec 2024 15:27:59 -0500 Subject: [PATCH 102/281] incremental progress on parser arrow/colon precedence --- test/Test_Menhir.re | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 4535235911..5e18170ace 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -485,7 +485,27 @@ let tests = menhir_maketerm_equivalent_test("Empty Type Hole", "let g: ? = 7 in g"), menhir_maketerm_equivalent_test( "Pattern with type ascription", - "fun b: Bool -> b", + "fun b : Bool -> b", + ), + menhir_only_test( + "Type Hole in arrow cast", + Fun( + Cast( + Var("b") |> Pat.fresh, + Arrow( + Unknown(Hole(EmptyHole)) |> Typ.fresh, + Unknown(Hole(EmptyHole)) |> Typ.fresh, + ) + |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Pat.fresh, + EmptyHole |> Exp.fresh, + None, + None, + ) + |> Exp.fresh, + "fun b : ? -> ? -> ?", ), ] @ { From 4bf139a6447165e50281ffb7c0619969f25dc0ec Mon Sep 17 00:00:00 2001 From: Matt Keenan Date: Mon, 2 Dec 2024 15:17:33 -0500 Subject: [PATCH 103/281] remove req-value --- src/haz3lcore/dynamics/Builtins.re | 19 +-- src/haz3lcore/dynamics/Evaluator.re | 94 ++++---------- src/haz3lcore/dynamics/EvaluatorStep.re | 38 ------ src/haz3lcore/dynamics/Transition.re | 155 ++++++++---------------- src/haz3lcore/dynamics/Unboxing.re | 46 ++++++- src/haz3lcore/dynamics/ValueChecker.re | 59 +++------ 6 files changed, 141 insertions(+), 270 deletions(-) diff --git a/src/haz3lcore/dynamics/Builtins.re b/src/haz3lcore/dynamics/Builtins.re index c47617edc6..21edcfe19e 100644 --- a/src/haz3lcore/dynamics/Builtins.re +++ b/src/haz3lcore/dynamics/Builtins.re @@ -1,3 +1,4 @@ +open Util; open DHExp; /* @@ -12,13 +13,13 @@ open DHExp; [@deriving (show({with_path: false}), sexp)] type builtin = | Const(Typ.t, DHExp.t) - | Fn(Typ.t, Typ.t, DHExp.t => DHExp.t); + | Fn(Typ.t, Typ.t, DHExp.t => option(DHExp.t)); [@deriving (show({with_path: false}), sexp)] type t = VarMap.t_(builtin); [@deriving (show({with_path: false}), sexp)] -type forms = VarMap.t_(DHExp.t => DHExp.t); +type forms = VarMap.t_(DHExp.t => option(DHExp.t)); type result = Result.t(DHExp.t, EvaluatorError.t); @@ -29,7 +30,7 @@ let fn = name: Var.t, t1: Typ.term, t2: Typ.term, - impl: DHExp.t => DHExp.t, + impl: DHExp.t => option(DHExp.t), // None if indet builtins: t, ) : t => @@ -51,8 +52,8 @@ module Pervasives = { let unary = (f: DHExp.t => result, d: DHExp.t) => { switch (f(d)) { - | Ok(r') => r' - | Error(e) => EvaluatorError.Exception(e) |> raise + | Ok(r') => Some(r') + | Error(_) => None }; }; @@ -60,8 +61,8 @@ module Pervasives = { switch (term_of(d)) { | Tuple([d1, d2]) => switch (f(d1, d2)) { - | Ok(r) => r - | Error(e) => EvaluatorError.Exception(e) |> raise + | Ok(r) => Some(r) + | Error(_) => None } | _ => raise(EvaluatorError.Exception(InvalidBoxedTuple(d))) }; @@ -71,8 +72,8 @@ module Pervasives = { switch (term_of(d)) { | Tuple([d1, d2, d3]) => switch (f(d1, d2, d3)) { - | Ok(r) => r - | Error(e) => EvaluatorError.Exception(e) |> raise + | Ok(r) => Some(r) + | Error(_) => None } | _ => raise(EvaluatorError.Exception(InvalidBoxedTuple(d))) }; diff --git a/src/haz3lcore/dynamics/Evaluator.re b/src/haz3lcore/dynamics/Evaluator.re index 628b493e1d..89633ed371 100644 --- a/src/haz3lcore/dynamics/Evaluator.re +++ b/src/haz3lcore/dynamics/Evaluator.re @@ -23,8 +23,7 @@ open Result; module EvaluatorEVMode: { type status = - | BoxedValue - | Indet + | Final | Uneval; include @@ -32,94 +31,45 @@ module EvaluatorEVMode: { type state = ref(EvaluatorState.t) and type result = (status, DHExp.t); } = { type status = - | BoxedValue - | Indet + | Final | Uneval; type result = (status, DHExp.t); - type reqstate = - | BoxedReady - | IndetReady - | IndetBlocked; - - let (&&) = (x, y) => - switch (x, y) { - | (IndetBlocked, _) => IndetBlocked - | (_, IndetBlocked) => IndetBlocked - | (IndetReady, _) => IndetReady - | (_, IndetReady) => IndetReady - | (BoxedReady, BoxedReady) => BoxedReady - }; - - type requirement('a) = (reqstate, 'a); + type requirement('a) = 'a; - type requirements('a, 'b) = (reqstate, 'a, 'b); // cumulative state, cumulative arguments, cumulative 'undo' + type requirements('a, 'b) = ('a, 'b); // cumulative arguments, cumulative 'undo' type state = ref(EvaluatorState.t); let update_test = (state, id, v) => state := EvaluatorState.add_test(state^, id, v); - let req_value = (f, _, x) => - switch (f(x)) { - | (BoxedValue, x) => (BoxedReady, x) - | (Indet, x) => (IndetBlocked, x) - | (Uneval, _) => failwith("Unexpected Uneval") - }; - - let rec req_all_value = (f, i) => - fun - | [] => (BoxedReady, []) - | [x, ...xs] => { - let (r1, x') = req_value(f, x => x, x); - let (r2, xs') = req_all_value(f, i, xs); - (r1 && r2, [x', ...xs']); - }; - - let req_final = (f, _, x) => - switch (f(x)) { - | (BoxedValue, x) => (BoxedReady, x) - | (Indet, x) => (IndetReady, x) - | (Uneval, _) => failwith("Unexpected Uneval") - }; + let req_final = (f, _, x) => f(x) |> snd; let rec req_all_final = (f, i) => fun - | [] => (BoxedReady, []) + | [] => [] | [x, ...xs] => { - let (r1, x') = req_final(f, x => x, x); - let (r2, xs') = req_all_final(f, i, xs); - (r1 && r2, [x', ...xs']); + let x' = req_final(f, x => x, x); + let xs' = req_all_final(f, i, xs); + [x', ...xs']; }; - let req_final_or_value = (f, _, x) => - switch (f(x)) { - | (BoxedValue, x) => (BoxedReady, (x, true)) - | (Indet, x) => (IndetReady, (x, false)) - | (Uneval, _) => failwith("Unexpected Uneval") - }; - - let otherwise = (_, c) => (BoxedReady, (), c); + let otherwise = (_, c) => ((), c); - let (and.) = ((r1, x1, c1), (r2, x2)) => (r1 && r2, (x1, x2), c1(x2)); + let (and.) = ((x1, c1), x2) => ((x1, x2), c1(x2)); - let (let.) = ((r, x, c), s) => - switch (r, s(x)) { - | (BoxedReady, Step({expr, state_update, is_value: true, _})) => - state_update(); - (BoxedValue, expr); - | (IndetReady, Step({expr, state_update, is_value: true, _})) => + let (let.) = ((x, c), s) => + switch (s(x)) { + | Step({expr, state_update, is_value: true, _}) => state_update(); - (Indet, expr); - | (BoxedReady, Step({expr, state_update, is_value: false, _})) - | (IndetReady, Step({expr, state_update, is_value: false, _})) => + (Final, expr); + | Step({expr, state_update, is_value: false, _}) => state_update(); (Uneval, expr); - | (BoxedReady, Constructor) => (BoxedValue, c) - | (IndetReady, Constructor) => (Indet, c) - | (IndetBlocked, _) => (Indet, c) - | (_, Value) => (BoxedValue, c) - | (_, Indet) => (Indet, c) + | Constructor + | Value + | Indet => (Final, c) }; }; module Eval = Transition(EvaluatorEVMode); @@ -127,8 +77,7 @@ module Eval = Transition(EvaluatorEVMode); let rec evaluate = (state, env, d) => { let u = Eval.transition(evaluate, state, env, d); switch (u) { - | (BoxedValue, x) => (BoxedValue, x) - | (Indet, x) => (Indet, x) + | (Final, x) => (Final, x) | (Uneval, x) => evaluate(state, env, x) }; }; @@ -139,8 +88,7 @@ let evaluate = (env, {d}: Elaborator.Elaboration.t) => { let result = evaluate(state, env, d); let result = switch (result) { - | (BoxedValue, x) => BoxedValue(x |> DHExp.repair_ids) - | (Indet, x) => Indet(x |> DHExp.repair_ids) + | (Final, x) => BoxedValue(x |> DHExp.repair_ids) | (Uneval, x) => Indet(x |> DHExp.repair_ids) }; (state^, result); diff --git a/src/haz3lcore/dynamics/EvaluatorStep.re b/src/haz3lcore/dynamics/EvaluatorStep.re index 0882fa223f..7418591e8d 100644 --- a/src/haz3lcore/dynamics/EvaluatorStep.re +++ b/src/haz3lcore/dynamics/EvaluatorStep.re @@ -58,17 +58,6 @@ module Decompose = { type requirements('a, 'b) = ('b, Result.t, ClosureEnvironment.t, 'a); type result = Result.t; - let req_value = (cont, wr, d) => { - switch (cont(d)) { - | Result.Indet => (Result.Indet, d) - | Result.BoxedValue => (Result.BoxedValue, d) - | Result.Step(objs) => ( - Result.Step(List.map(EvalObj.wrap(wr), objs)), - d, - ) - }; - }; - let (&&): (Result.t, Result.t) => Result.t = (u, v) => switch (u, v) { @@ -81,18 +70,6 @@ module Decompose = { | (BoxedValue, BoxedValue) => BoxedValue }; - let rec req_all_value' = (cont, wr, ds') => - fun - | [] => (Result.BoxedValue, []) - | [d, ...ds] => { - let (r1, v) = req_value(cont, wr(_, (ds', ds)), d); - let (r2, vs) = req_all_value'(cont, wr, [d, ...ds'], ds); - (r1 && r2, [v, ...vs]); - }; - let req_all_value = (cont, wr, ds) => { - req_all_value'(cont, wr, [], ds); - }; - let req_final = (cont, wr, d) => { ( switch (cont(d)) { @@ -105,17 +82,6 @@ module Decompose = { ); }; - let req_final_or_value = (cont, wr, d) => { - switch (cont(d)) { - | Result.Indet => (Result.BoxedValue, (d, false)) - | Result.BoxedValue => (Result.BoxedValue, (d, true)) - | Result.Step(objs) => ( - Result.Step(List.map(EvalObj.wrap(wr), objs)), - (d, false), - ) - }; - }; - let rec req_all_final' = (cont, wr, ds') => fun | [] => (Result.BoxedValue, []) @@ -175,13 +141,9 @@ module TakeStep = { type result = option(DHExp.t); // Assume that everything is either value or final as required. - let req_value = (_, _, d) => d; - let req_all_value = (_, _, ds) => ds; let req_final = (_, _, d) => d; let req_all_final = (_, _, ds) => ds; - let req_final_or_value = (_, _, d) => (d, true); - let (let.) = (rq: requirements('a, DHExp.t), rl: 'a => rule) => switch (rl(rq)) { | Step({expr, state_update, _}) => diff --git a/src/haz3lcore/dynamics/Transition.re b/src/haz3lcore/dynamics/Transition.re index 5c936426b9..de904c4532 100644 --- a/src/haz3lcore/dynamics/Transition.re +++ b/src/haz3lcore/dynamics/Transition.re @@ -18,11 +18,10 @@ open PatternMatch; to wrap the expression back up if the step couldn't be evaluated. This is followed by a series of `and. d1' = req_final(req(state, env), , )` - which indicate that in order to evaluate the step, must be final. (req_value - is also available if it needs to be a value). Note that if successful, d1' will - be the fully-evaluated version of d1. The sub-expressions are all enumerated by - the field, so i=0 indicates that it is the first sub-expression, i=1 the - second etc. + which indicate that in order to evaluate the step, must be final. Note that + if successful, d1' will be the fully-evaluated version of d1. The sub-expressions + are all enumerated by the field, so i=0 indicates that it is the first + sub-expression, i=1 the second etc. Finally, we have the Step construct that defines the actual step. Note "Step"s should be used if and only if they change the expression. If they do not change @@ -107,16 +106,6 @@ module type EV_MODE = { type requirement('a); type requirements('a, 'b); - let req_value: - (DHExp.t => result, EvalCtx.t => EvalCtx.t, DHExp.t) => - requirement(DHExp.t); - let req_all_value: - ( - DHExp.t => result, - (EvalCtx.t, (list(DHExp.t), list(DHExp.t))) => EvalCtx.t, - list(DHExp.t) - ) => - requirement(list(DHExp.t)); let req_final: (DHExp.t => result, EvalCtx.t => EvalCtx.t, DHExp.t) => requirement(DHExp.t); @@ -127,9 +116,6 @@ module type EV_MODE = { list(DHExp.t) ) => requirement(list(DHExp.t)); - let req_final_or_value: - (DHExp.t => result, EvalCtx.t => EvalCtx.t, DHExp.t) => - requirement((DHExp.t, bool)); let (let.): (requirements('a, DHExp.t), 'a => rule) => result; let (and.): @@ -257,18 +243,13 @@ module Transition = (EV: EV_MODE) => { }); } | Test(d'') => - let. _ = otherwise(env, ((d, _)) => Test(d) |> rewrap) - and. (d', is_value) = - req_final_or_value(req(state, env), d => Test(d) |> wrap_ctx, d''); + let. _ = otherwise(env, d => Test(d) |> rewrap) + and. d' = req_final(req(state, env), d => Test(d) |> wrap_ctx, d''); let result: TestStatus.t = - if (is_value) { - switch (Unboxing.unbox(Bool, d')) { - | DoesNotMatch - | IndetMatch => Indet - | Matches(b) => b ? Pass : Fail - }; - } else { - Indet; + switch (Unboxing.unbox(Bool, d')) { + | DoesNotMatch + | IndetMatch => Indet + | Matches(b) => b ? Pass : Fail }; Step({ expr: Tuple([]) |> fresh, @@ -280,8 +261,9 @@ module Transition = (EV: EV_MODE) => { | TypAp(d, tau) => let. _ = otherwise(env, d => TypAp(d, tau) |> rewrap) and. d' = - req_value(req(state, env), d => TypAp(d, tau) |> wrap_ctx, d); - switch (DHExp.term_of(d')) { + req_final(req(state, env), d => TypAp(d, tau) |> wrap_ctx, d); + let-unbox typfun = (TypFun, d'); + switch (typfun) { | TypFun(utpat, tfbody, name) => /* Rule ITTLam */ Step({ @@ -298,11 +280,7 @@ module Transition = (EV: EV_MODE) => { kind: TypFunAp, is_value: false, }) - | Cast( - d'', - {term: Forall(tp1, _), _} as t1, - {term: Forall(tp2, _), _} as t2, - ) => + | TFunCast(d'', tp1, t1, tp2, t2) => /* Rule ITTApCast */ Step({ expr: @@ -316,7 +294,6 @@ module Transition = (EV: EV_MODE) => { kind: CastTypAp, is_value: false, }) - | _ => raise(EvaluatorError.Exception(InvalidBoxedTypFun(d'))) }; | DeferredAp(d1, ds) => let. _ = otherwise(env, (d1, ds) => DeferredAp(d1, ds) |> rewrap) @@ -334,18 +311,15 @@ module Transition = (EV: EV_MODE) => { ); Value; | Ap(dir, d1, d2) => - let. _ = otherwise(env, (d1, (d2, _)) => Ap(dir, d1, d2) |> rewrap) + let. _ = otherwise(env, (d1, d2) => Ap(dir, d1, d2) |> rewrap) and. d1' = - req_value(req(state, env), d1 => Ap1(dir, d1, d2) |> wrap_ctx, d1) - and. (d2', d2_is_value) = - req_final_or_value( - req(state, env), - d2 => Ap2(dir, d1, d2) |> wrap_ctx, - d2, - ); - switch (DHExp.term_of(d1')) { + req_final(req(state, env), d1 => Ap1(dir, d1, d2) |> wrap_ctx, d1) + and. d2' = + req_final(req(state, env), d2 => Ap2(dir, d1, d2) |> wrap_ctx, d2); + let-unbox unboxed_fun = (Fun, d1'); + switch (unboxed_fun) { | Constructor(_) => Constructor - | Fun(dp, d3, Some(env'), _) => + | FunEnv(dp, d3, env') => let.match env'' = (env', matches(dp, d2')); Step({ expr: Closure(env'', d3) |> fresh, @@ -353,11 +327,7 @@ module Transition = (EV: EV_MODE) => { kind: FunAp, is_value: false, }); - | Cast( - d3', - {term: Arrow(ty1, ty2), _}, - {term: Arrow(ty1', ty2'), _}, - ) => + | FunCast(d3', ty1, ty2, ty1', ty2') => Step({ expr: Cast( @@ -371,28 +341,21 @@ module Transition = (EV: EV_MODE) => { is_value: false, }) | BuiltinFun(ident) => - if (d2_is_value) { - Step({ - expr: { - let builtin = - VarMap.lookup(Builtins.forms_init, ident) - |> OptUtil.get(() => { - /* This exception should never be raised because there is - no way for the user to create a BuiltinFun. They are all - inserted into the context before evaluation. */ - raise( - EvaluatorError.Exception(InvalidBuiltin(ident)), - ) - }); - builtin(d2'); - }, - state_update, - kind: BuiltinAp(ident), - is_value: false // Not necessarily a value because of InvalidOperations - }); - } else { - Indet; - } + let builtin = + VarMap.lookup(Builtins.forms_init, ident) + |> OptUtil.get(() => { + /* This exception should never be raised because there is + no way for the user to create a BuiltinFun. They are all + inserted into the context before evaluation. */ + raise( + EvaluatorError.Exception(InvalidBuiltin(ident)), + ) + }); + switch (builtin(d2')) { + | Some(expr) => + Step({expr, state_update, kind: BuiltinAp(ident), is_value: false}) + | None => Indet + }; | DeferredAp(d3, d4s) => let n_args = List.length( @@ -430,22 +393,6 @@ module Transition = (EV: EV_MODE) => { kind: DeferredAp, is_value: false, }); - | Cast(_) - | FailedCast(_) => Indet - | FixF(_) => - print_endline(Exp.show(d1)); - print_endline(Exp.show(d1')); - print_endline("FIXF"); - failwith("FixF in Ap"); - | _ => - Step({ - expr: { - raise(EvaluatorError.Exception(InvalidBoxedFun(d1'))); - }, - state_update, - kind: InvalidStep, - is_value: true, - }) }; | Deferral(_) => let. _ = otherwise(env, d); @@ -461,7 +408,7 @@ module Transition = (EV: EV_MODE) => { | If(c, d1, d2) => let. _ = otherwise(env, c => If(c, d1, d2) |> rewrap) and. c' = - req_value(req(state, env), c => If1(c, d1, d2) |> wrap_ctx, c); + req_final(req(state, env), c => If1(c, d1, d2) |> wrap_ctx, c); let-unbox b = (Bool, c'); Step({ expr: { @@ -478,7 +425,7 @@ module Transition = (EV: EV_MODE) => { | UnOp(Int(Minus), d1) => let. _ = otherwise(env, d1 => UnOp(Int(Minus), d1) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), c => UnOp(Int(Minus), c) |> wrap_ctx, d1, @@ -493,7 +440,7 @@ module Transition = (EV: EV_MODE) => { | UnOp(Bool(Not), d1) => let. _ = otherwise(env, d1 => UnOp(Bool(Not), d1) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), c => UnOp(Bool(Not), c) |> wrap_ctx, d1, @@ -508,7 +455,7 @@ module Transition = (EV: EV_MODE) => { | BinOp(Bool(And), d1, d2) => let. _ = otherwise(env, d1 => BinOp(Bool(And), d1, d2) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), d1 => BinOp1(Bool(And), d1, d2) |> wrap_ctx, d1, @@ -523,7 +470,7 @@ module Transition = (EV: EV_MODE) => { | BinOp(Bool(Or), d1, d2) => let. _ = otherwise(env, d1 => BinOp(Bool(Or), d1, d2) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), d1 => BinOp1(Bool(Or), d1, d2) |> wrap_ctx, d1, @@ -538,13 +485,13 @@ module Transition = (EV: EV_MODE) => { | BinOp(Int(op), d1, d2) => let. _ = otherwise(env, (d1, d2) => BinOp(Int(op), d1, d2) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), d1 => BinOp1(Int(op), d1, d2) |> wrap_ctx, d1, ) and. d2' = - req_value( + req_final( req(state, env), d2 => BinOp2(Int(op), d1, d2) |> wrap_ctx, d2, @@ -588,13 +535,13 @@ module Transition = (EV: EV_MODE) => { let. _ = otherwise(env, (d1, d2) => BinOp(Float(op), d1, d2) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), d1 => BinOp1(Float(op), d1, d2) |> wrap_ctx, d1, ) and. d2' = - req_value( + req_final( req(state, env), d2 => BinOp2(Float(op), d1, d2) |> wrap_ctx, d2, @@ -627,13 +574,13 @@ module Transition = (EV: EV_MODE) => { let. _ = otherwise(env, (d1, d2) => BinOp(String(op), d1, d2) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), d1 => BinOp1(String(op), d1, d2) |> wrap_ctx, d1, ) and. d2' = - req_value( + req_final( req(state, env), d2 => BinOp2(String(op), d1, d2) |> wrap_ctx, d2, @@ -664,7 +611,7 @@ module Transition = (EV: EV_MODE) => { and. d1' = req_final(req(state, env), d1 => Cons1(d1, d2) |> wrap_ctx, d1) and. d2' = - req_value(req(state, env), d2 => Cons2(d1, d2) |> wrap_ctx, d2); + req_final(req(state, env), d2 => Cons2(d1, d2) |> wrap_ctx, d2); let-unbox ds = (List, d2'); Step({ expr: ListLit([d1', ...ds]) |> fresh, @@ -675,13 +622,13 @@ module Transition = (EV: EV_MODE) => { | ListConcat(d1, d2) => let. _ = otherwise(env, (d1, d2) => ListConcat(d1, d2) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), d1 => ListConcat1(d1, d2) |> wrap_ctx, d1, ) and. d2' = - req_value( + req_final( req(state, env), d2 => ListConcat2(d1, d2) |> wrap_ctx, d2, diff --git a/src/haz3lcore/dynamics/Unboxing.re b/src/haz3lcore/dynamics/Unboxing.re index 400620026c..07bde372b3 100644 --- a/src/haz3lcore/dynamics/Unboxing.re +++ b/src/haz3lcore/dynamics/Unboxing.re @@ -15,6 +15,17 @@ open Util; the inner lists may still have casts around them after unboxing. */ +type unboxed_tfun = + | TypFun(TPat.t, Exp.t, option(string)) + | TFunCast(DHExp.t, TPat.t, Typ.t, TPat.t, Typ.t); + +type unboxed_fun = + | Constructor(string) + | FunEnv(Pat.t, Exp.t, ClosureEnvironment.t) + | FunCast(DHExp.t, Typ.t, Typ.t, Typ.t, Typ.t) + | BuiltinFun(string) + | DeferredAp(DHExp.t, list(DHExp.t)); + type unbox_request('a) = | Int: unbox_request(int) | Float: unbox_request(float) @@ -24,7 +35,9 @@ type unbox_request('a) = | List: unbox_request(list(DHExp.t)) | Cons: unbox_request((DHExp.t, DHExp.t)) | SumNoArg(string): unbox_request(unit) - | SumWithArg(string): unbox_request(DHExp.t); + | SumWithArg(string): unbox_request(DHExp.t) + | TypFun: unbox_request(unboxed_tfun) + | Fun: unbox_request(unboxed_fun); type unboxed('a) = | DoesNotMatch @@ -135,6 +148,35 @@ let rec unbox: type a. (unbox_request(a), DHExp.t) => unboxed(a) = }; // There should be some sort of failure here when the cast doesn't go through. + /* Function-like things can look like the following when values */ + | (Fun, Constructor(name, _)) => Matches(Constructor(name)) // Perhaps we should check if the constructor actually is a function? + | (Fun, Fun(dp, d3, Some(env'), _)) => Matches(FunEnv(dp, d3, env')) + | ( + Fun, + Cast( + d3', + {term: Arrow(ty1, ty2), _}, + {term: Arrow(ty1', ty2'), _}, + ), + ) => + Matches(FunCast(d3', ty1, ty2, ty1', ty2')) + | (Fun, BuiltinFun(name)) => Matches(BuiltinFun(name)) + | (Fun, DeferredAp(d1, ds)) => Matches(DeferredAp(d1, ds)) + + /* TypFun-like things can look like the following when values */ + | (TypFun, TypFun(utpat, tfbody, name)) => + Matches(TypFun(utpat, tfbody, name)) + // Note: We might be able to handle this cast like other casts + | ( + TypFun, + Cast( + d'', + {term: Forall(tp1, _), _} as t1, + {term: Forall(tp2, _), _} as t2, + ), + ) => + Matches(TFunCast(d'', tp1, t1, tp2, t2)) + /* Any cast from unknown is indet */ | (_, Cast(_, {term: Unknown(_), _}, _)) => IndetMatch @@ -169,6 +211,8 @@ let rec unbox: type a. (unbox_request(a), DHExp.t) => unboxed(a) = | SumNoArg(_) | SumWithArg(_) => raise(EvaluatorError.Exception(InvalidBoxedSumConstructor(expr))) + | Fun => raise(EvaluatorError.Exception(InvalidBoxedFun(expr))) + | TypFun => raise(EvaluatorError.Exception(InvalidBoxedTypFun(expr))) } /* Forms that are not yet or will never be a value */ diff --git a/src/haz3lcore/dynamics/ValueChecker.re b/src/haz3lcore/dynamics/ValueChecker.re index a6e5ab30f0..c0eeb22d96 100644 --- a/src/haz3lcore/dynamics/ValueChecker.re +++ b/src/haz3lcore/dynamics/ValueChecker.re @@ -11,66 +11,35 @@ module ValueCheckerEVMode: { type state = unit; type result = t; - type requirement('a) = ('a, (result, bool)); - type requirements('a, 'b) = ('a, (result, bool)); + type requirement('a) = ('a, result); + type requirements('a, 'b) = ('a, result); - let combine = ((r1, b1), (r2, b2)) => ( + let combine = (r1, r2) => switch (r1, r2) { | (Expr, _) => Expr | (_, Expr) => Expr | (Indet, _) => Indet | (_, Indet) => Indet | (Value, Value) => Value - }, - b1 && b2, - ); + }; - let req_value = (vc, _, d) => ( - d, - switch (vc(d)) { - | Value => (Value, true) - | Indet => (Indet, false) - | Expr => (Expr, false) - }, - ); - let req_all_value = (vc, _, ds) => - List.fold_right( - ((v1, r1), (v2, r2)) => ([v1, ...v2], combine(r1, r2)), - List.map(req_value(vc, x => x), ds), - ([], (Value, true)), - ); - let req_final = (vc, _, d) => ( - d, - switch (vc(d)) { - | Value => (Value, true) - | Indet => (Indet, true) - | Expr => (Expr, false) - }, - ); + let req_final = (vc, _, d) => (d, vc(d)); let req_all_final = (vc, _, ds) => List.fold_right( ((v1, r1), (v2, r2)) => ([v1, ...v2], combine(r1, r2)), List.map(req_final(vc, x => x), ds), - ([], (Value, true)), + ([], Value), ); - let req_final_or_value = (vc, _, d) => - switch (vc(d)) { - | Value => ((d, true), (Value, true)) - | Indet => ((d, false), (Value, true)) - | Expr => ((d, false), (Value, false)) - }; - - let otherwise = (_, _) => ((), (Value, true)); + let otherwise = (_, _) => ((), Value); - let (let.) = ((v, (r, b)), rule) => - switch (b, r, rule(v)) { - | (_, _, Constructor) => r - | (_, Expr, Indet) => Expr - | (_, _, Indet) => Indet - | (_, _, Value) => Value - | (true, _, Step(_)) => Expr - | (false, _, Step(_)) => r + let (let.) = ((v, r), rule) => + switch (r, rule(v)) { + | (_, Constructor) => r + | (Expr, Indet) => Expr + | (_, Indet) => Indet + | (_, Value) => Value + | (_, Step(_)) => Expr }; let (and.) = ((v1, r1), (v2, r2)) => { From 286352d773193747090f06df96d90e250c26aa00 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 9 Dec 2024 10:14:47 -0500 Subject: [PATCH 104/281] Add parens around ascription in function pattern for tests --- test/Test_Menhir.re | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 5e18170ace..7a89d2ebea 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -485,16 +485,19 @@ let tests = menhir_maketerm_equivalent_test("Empty Type Hole", "let g: ? = 7 in g"), menhir_maketerm_equivalent_test( "Pattern with type ascription", - "fun b : Bool -> b", + "fun (b : Bool) -> b", ), menhir_only_test( "Type Hole in arrow cast", Fun( Cast( Var("b") |> Pat.fresh, - Arrow( - Unknown(Hole(EmptyHole)) |> Typ.fresh, - Unknown(Hole(EmptyHole)) |> Typ.fresh, + Parens( + Arrow( + Unknown(Hole(EmptyHole)) |> Typ.fresh, + Unknown(Hole(EmptyHole)) |> Typ.fresh, + ) + |> Typ.fresh, ) |> Typ.fresh, Unknown(Internal) |> Typ.fresh, @@ -505,7 +508,7 @@ let tests = None, ) |> Exp.fresh, - "fun b : ? -> ? -> ?", + "fun b : (? -> ?) -> ?", ), ] @ { From 87729b90dd0d6f06c84fb646ef749f9042e9552a Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 9 Dec 2024 16:34:44 -0500 Subject: [PATCH 105/281] More progress on parser --- src/haz3lmenhir/Conversion.re | 2 + src/haz3lmenhir/Parser.mly | 27 +++++++++---- test/Test_Menhir.re | 71 +++++++++++++++++++++++++++++++---- 3 files changed, 85 insertions(+), 15 deletions(-) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 894849db76..2448ddf8ff 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -289,6 +289,8 @@ and Typ: { } | None => Variant(name, [], None) } + | UnknownType(EmptyHole) => + BadEntry(Unknown(Hole(EmptyHole)) |> Haz3lcore.Typ.fresh) // TODO Figure out if this is correct | _ => raise( Failure( diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 903a22cc73..46950564f5 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -212,11 +212,17 @@ binExp: %inline sumTerm: | i = CONSTRUCTOR_IDENT; t = tupleType { SumTerm(i, Some(t)) } | i = CONSTRUCTOR_IDENT { SumTerm(i, None) } + | QUESTION { UnknownType(EmptyHole) } -sumTyp: + +plusLeadingSumTyp: | PLUS; s = sumTerm; { SumTyp(s, None) } %prec SUM_TYP - | PLUS; s = sumTerm; t = sumTyp { SumTyp(s, Some(t)) } + | PLUS; s = sumTerm; t = plusLeadingSumTyp { SumTyp(s, Some(t)) } +sumTyp: + | s = plusLeadingSumTyp; { s } + | s = sumTerm; t = plusLeadingSumTyp { SumTyp(s, Some(t)) } + typ: | c = CONSTRUCTOR_IDENT { TypVar(c) } @@ -233,9 +239,7 @@ typ: | t1 = typ; DASH_ARROW; t2 = typ { ArrowType(t1, t2) } | s = sumTyp; { s } -pat: - | p1 = pat; COLON; t1 = typ; { CastPat(p1, t1, UnknownType(Internal)) } - | p1 = pat; OPEN_CURLY; t1 = typ; EQUAL_ARROW; t2 = typ; CLOSE_CURLY { CastPat(p1, t1, t2) } +nonAscriptingPat: | OPEN_PAREN; p = pat; CLOSE_PAREN { p } | OPEN_PAREN; p = pat; COMMA; pats = separated_list(COMMA, pat); CLOSE_PAREN { TuplePat(p :: pats) } | QUESTION; P_PAT; s = STRING { InvalidPat(s) } @@ -250,9 +254,17 @@ pat: | s = STRING { StringPat s} | TRUE { BoolPat true} | FALSE {BoolPat false} + +funPat: + | OPEN_PAREN; p1 = pat; COLON; t1 = typ; CLOSE_PAREN; { CastPat(p1, t1, UnknownType(Internal)) } // TODO Shift/reduce conflict but I'm pretty sure the end parse state is the same either way + | p = nonAscriptingPat; { p } + +pat: + | p1 = pat; COLON; t1 = typ; { CastPat(p1, t1, UnknownType(Internal)) } (* | p1 = pat; AS; p2 = pat; { AsPat(p1, p2) } *) | p1 = pat; CONS; p2 = pat { ConsPat(p1, p2) } | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } + | p = nonAscriptingPat; { p } rul: @@ -262,8 +274,8 @@ case: | CASE; e = exp; l = list(rul); END; { CaseExp(e, l) } funExp: - | FUN; p = pat; DASH_ARROW; e1 = exp; { Fun (p, e1, None) } - | NAMED_FUN; name = IDENT; p = pat; DASH_ARROW; e1 = exp { Fun (p, e1, Some(name)) } + | FUN; p = funPat; DASH_ARROW; e1 = exp; { Fun (p, e1, None) } + | NAMED_FUN; name = IDENT; p = funPat; DASH_ARROW; e1 = exp { Fun (p, e1, Some(name)) } %inline ifExp: @@ -301,6 +313,7 @@ exp: | c = case { c } | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ListExp(e) } | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } + | f = exp; OPEN_PAREN; a = exp; COMMA; tl = separated_nonempty_list(COMMA, exp); CLOSE_PAREN { ApExp(f, TupleExp(a :: tl)) } | LET; i = pat; SINGLE_EQUAL; e1 = exp; IN; e2 = exp { Let (i, e1, e2) } %prec LET_EXP | i = ifExp { i } | e1 = exp; QUESTION; OPEN_CURLY; t1 = typ; EQUAL_ARROW; t2 = typ; CLOSE_CURLY {FailedCast(e1, t1, t2)} diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 7a89d2ebea..f4c931b7c3 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -508,7 +508,36 @@ let tests = None, ) |> Exp.fresh, - "fun b : (? -> ?) -> ?", + "fun (b : ? -> ?) -> ?", + ), + menhir_only_test( + "multiargument function", + Ap( + Forward, + Var("f") |> Exp.fresh, + Tuple([Int(1) |> Exp.fresh, Int(2) |> Exp.fresh]) |> Exp.fresh, + ) + |> Exp.fresh, + "f(1, 2)", + ), + menhir_only_test( + "Sum type definition without leading plus", + TyAlias( + Var("GoodSum") |> TPat.fresh, + Sum([ + Variant("A", [], None), + Variant("B", [], None), + Variant("C", [], Some(Int |> Typ.fresh)), + ]) + |> Typ.fresh, + Int(1) |> Exp.fresh, + ) + |> Exp.fresh, + "type GoodSum = A + B + C(Int) in 1", + ), + menhir_maketerm_equivalent_test( + "partial sum type", + "type Partial = Ok(?) + ? in ?", ), ] @ { @@ -517,8 +546,31 @@ let tests = Str.global_replace(re, "", str); }; let replace_holes = str => { - let re = Str.regexp("= in"); - Str.global_replace(re, "= ? in", str); + // List of lines in doc buffers that are not correctly formed + let failing_parse_strings = [ + "type ? = badTypeToken in", + "type NotASum = NotInSum(Bool) in", + "+ notvalid", + "type Bool = ? in", + "+ Int(Int)", + "+ Int(Int)", + "+ (?)(Int)", + "+ A(Bool)(Int)", + "type (?, ?) = ? in", + "+ Bool", + ]; + let remove_failing_parse = str => { + List.fold_left( + (acc, s) => Str.global_replace(Str.regexp_string(s), "", acc), + str, + failing_parse_strings, + ); + }; + + str + |> Str.global_replace(Str.regexp("= in"), "= ? in", _) + |> remove_failing_parse + |> Str.global_replace(Str.regexp("^ *\n"), "", _); }; let (_, slides: list((string, PersistentZipper.t)), _) = Haz3lweb.Init.startup.documentation; @@ -531,13 +583,16 @@ let tests = let cleaned_source = replace_holes(strip_comments(slide.backup_text)); print_endline(cleaned_source); - alco_check( - "Menhir parse does not match MakeTerm", - make_term_parse(slide.backup_text), + let menhir_parsed = Haz3lmenhir.Conversion.Exp.of_menhir_ast( Haz3lmenhir.Interface.parse_program(cleaned_source), - ), - ); + ); + (); + // alco_check( + // "Menhir parse does not match MakeTerm", + // make_term_parse(slide.backup_text), + // menhir_parsed, + // ); }, ) }, From a76f253036f031eaa48fe5db785d41f22411eb37 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 9 Dec 2024 16:35:08 -0500 Subject: [PATCH 106/281] Fix unused variable --- test/Test_Menhir.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index f4c931b7c3..fdb3c724d4 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -583,7 +583,7 @@ let tests = let cleaned_source = replace_holes(strip_comments(slide.backup_text)); print_endline(cleaned_source); - let menhir_parsed = + let _menhir_parsed = Haz3lmenhir.Conversion.Exp.of_menhir_ast( Haz3lmenhir.Interface.parse_program(cleaned_source), ); From 3d0637451c566506385f01241baf80541f704350 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 9 Dec 2024 16:36:20 -0500 Subject: [PATCH 107/281] Update Init.ml file with parentheses on function args --- src/haz3lweb/Init.ml | 1812 +++++++++++++++++++++++------------------- 1 file changed, 1013 insertions(+), 799 deletions(-) diff --git a/src/haz3lweb/Init.ml b/src/haz3lweb/Init.ml index c3d2de0aba..e224adef89 100644 --- a/src/haz3lweb/Init.ml +++ b/src/haz3lweb/Init.ml @@ -37,77 +37,176 @@ let startup : PersistentData.t = { zipper = "((selection((focus Left)(content())(mode \ - Normal)))(backpack())(relatives((siblings((((Grout((id \ - e87c8d67-9374-4a6f-ba01-5ec8f300b924)(shape \ + Normal)))(backpack())(relatives((siblings(()((Grout((id \ + cf0463b2-7b40-4400-85cf-306f8569897c)(shape \ Convex))))))(ancestors())))(caret Outer))"; - backup_text = ""; + backup_text = " "; }; { zipper = "((selection((focus Left)(content())(mode \ - Normal)))(backpack())(relatives((siblings((((Grout((id \ - e87c8d67-9374-4a6f-ba01-5ec8f300b924)(shape \ + Normal)))(backpack())(relatives((siblings(()((Grout((id \ + 8c114882-de72-42cc-9b45-70db97932b00)(shape \ Convex))))))(ancestors())))(caret Outer))"; - backup_text = ""; + backup_text = " "; }; { zipper = "((selection((focus Left)(content())(mode \ - Normal)))(backpack())(relatives((siblings((((Grout((id \ - e87c8d67-9374-4a6f-ba01-5ec8f300b924)(shape \ + Normal)))(backpack())(relatives((siblings(()((Grout((id \ + 89e71f0f-d71b-4d32-89df-04f76bf385e7)(shape \ Convex))))))(ancestors())))(caret Outer))"; - backup_text = ""; + backup_text = " "; }; { zipper = "((selection((focus Left)(content())(mode \ - Normal)))(backpack())(relatives((siblings((((Grout((id \ - e87c8d67-9374-4a6f-ba01-5ec8f300b924)(shape \ + Normal)))(backpack())(relatives((siblings(()((Grout((id \ + 6c81a411-ec78-437d-a5bf-5988bebf4f0f)(shape \ Convex))))))(ancestors())))(caret Outer))"; - backup_text = ""; + backup_text = " "; }; { zipper = "((selection((focus Left)(content())(mode \ - Normal)))(backpack())(relatives((siblings((((Grout((id \ - e87c8d67-9374-4a6f-ba01-5ec8f300b924)(shape \ + Normal)))(backpack())(relatives((siblings(()((Grout((id \ + 54908616-4efb-468e-8e42-3f1441f7ed7a)(shape \ Convex))))))(ancestors())))(caret Outer))"; - backup_text = ""; + backup_text = " "; }; { zipper = "((selection((focus Left)(content())(mode \ - Normal)))(backpack())(relatives((siblings((((Grout((id \ - e87c8d67-9374-4a6f-ba01-5ec8f300b924)(shape \ + Normal)))(backpack())(relatives((siblings(()((Grout((id \ + 5a39079f-81e2-428e-9ea1-4bb1a944944e)(shape \ Convex))))))(ancestors())))(caret Outer))"; - backup_text = ""; + backup_text = " "; }; { zipper = "((selection((focus Left)(content())(mode \ - Normal)))(backpack())(relatives((siblings((((Grout((id \ - e87c8d67-9374-4a6f-ba01-5ec8f300b924)(shape \ + Normal)))(backpack())(relatives((siblings(()((Grout((id \ + e57481eb-3f57-4061-8ae5-e3d127b8a22a)(shape \ Convex))))))(ancestors())))(caret Outer))"; - backup_text = ""; + backup_text = " "; }; { zipper = "((selection((focus Left)(content())(mode \ - Normal)))(backpack())(relatives((siblings((((Grout((id \ - e87c8d67-9374-4a6f-ba01-5ec8f300b924)(shape \ + Normal)))(backpack())(relatives((siblings(()((Grout((id \ + 102269ab-4f66-4b1f-b026-60290eb1680b)(shape \ Convex))))))(ancestors())))(caret Outer))"; - backup_text = ""; + backup_text = " "; }; ], [ ("scratch_0", Evaluation); ("scratch_1", Evaluation) ] ); documentation = - ( "Basic Reference", + ( "Casting", [ ( "Casting", { zipper = "((selection((focus Left)(content())(mode \ - Normal)))(backpack())(relatives((siblings(()((Secondary((id \ + Normal)))(backpack())(relatives((siblings(((Secondary((id \ + e22cb4de-e71f-437c-aa78-7dbddaf539b9)(content(Whitespace\" \ + \"))))(Tile((id \ + 369480f2-3180-45fe-ad84-d087ec385c7c)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ + f1cf30d1-5648-4a00-ab7f-3a6ddd790203)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ + 644e9674-214f-4d11-8679-6d3d920cc2ea)(label(a))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ + 01fecc9f-f74c-4505-b970-87738e766bd1)(label(,))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 15))(sort \ + Pat))((shape(Concave 15))(sort \ + Pat))))))(shards(0))(children())))(Secondary((id \ + 786d94c1-6e02-4925-b04d-a4a76d0d4e62)(content(Whitespace\" \ + \"))))(Tile((id \ + 2cc9c805-a00e-444f-a440-fbfa3d63c99d)(label(b))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children()))))))))(Tile((id \ + bcada562-fe9c-4f83-acd4-416e41ef4546)(label(:))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 12))(sort \ + Pat))((shape(Concave 12))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + 54b24744-488a-457e-9abf-f70d4947bf8e)(content(Whitespace\" \ + \"))))(Tile((id \ + 14508377-cc9d-420b-8d68-d7d5a7fd35c0)(label(\"(\"\")\"))(mold((out \ + Typ)(in_(Typ))(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0 1))(children(((Tile((id \ + 501dfb3c-f396-46d9-8838-380c842b63e3)(label(Int))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ + 58d2c431-0b68-485f-9fa5-3fbf8823a165)(label(,))(mold((out \ + Typ)(in_())(nibs(((shape(Concave 15))(sort \ + Typ))((shape(Concave 15))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + b8d97744-b2d7-43d6-a0e0-4cb376efb927)(content(Whitespace\" \ + \"))))(Tile((id \ + 8e3dd6c0-0cd8-4006-a23d-ac23094f5564)(label(?))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort \ + Typ))))))(shards(0))(children())))))))))))))(Secondary((id \ + 6cfb4cb5-8066-4a65-b197-b4155ba475f8)(content(Whitespace\" \ + \")))))()))(ancestors((((id \ + b569b6f7-d7fc-4248-b301-16d955623be9)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 14))(sort \ + Exp))))))(shards((0)(1)))(children(()())))(((Secondary((id \ + 005e18cc-6749-4a8d-85f5-513cf98bcbf1)(content(Whitespace\" \ + \")))))((Secondary((id \ + e547925e-3719-4132-a268-711329c13791)(content(Whitespace\" \ + \"))))(Tile((id \ + f989002e-7cf8-4163-93dd-1043941820c0)(label(a))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 35b2a690-ccac-466f-b90e-d651f823e56e)(content(Whitespace\" \ + \"))))(Tile((id \ + 18e0b965-1d34-45fd-9a69-9158d8099c33)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 6))(sort \ + Exp))((shape(Concave 6))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + b6a82bdb-5fe5-424b-a63c-3edcfb0d08a9)(content(Whitespace\" \ + \"))))(Tile((id \ + b7ed8465-5cd8-45ba-a30c-43f845b03341)(label(1))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + c1b1e3c2-2c9d-46e5-9053-b0d14f2174e7)(content(Whitespace\" \ + \")))))))(((id \ + dbc95f6f-0dac-413b-9a57-875c91d1bc19)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 17))(sort Exp))))))(shards((0 \ + 1)(2)))(children((((Secondary((id \ + 6d4f1f2b-2cb6-4a54-855c-eba41992f09a)(content(Whitespace\" \ + \"))))(Tile((id \ + b2f91c33-d0b4-4a42-8bdd-cb318b160df3)(label(f))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ + 3f84fcc2-2c28-4b76-b9c4-7a12a043ddb4)(label(:))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 12))(sort \ + Pat))((shape(Concave 12))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + 849c5444-d52d-407b-a91a-78ecd49eaec7)(content(Whitespace\" \ + \"))))(Tile((id \ + d99c9e74-3821-438c-8a00-2990985f1b27)(label(?))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + f23c1d14-e2c2-45b8-a766-af783330ef62)(content(Whitespace\" \ + \"))))(Tile((id \ + 3254d589-fc8c-44bd-af59-b32f30bf2194)(label(->))(mold((out \ + Typ)(in_())(nibs(((shape(Concave 5))(sort \ + Typ))((shape(Concave 5))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + 00c77afb-bc00-49a8-8e14-8b24e92793b3)(content(Whitespace\" \ + \"))))(Tile((id \ + cbcd2b8f-95e4-431c-853e-1bd3ebc0c0bd)(label(?))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + d9b539b4-0ed0-4ce0-a3c4-7c796959d9b2)(content(Whitespace\" \ + \"))))))())))(((Secondary((id \ 81369b05-3100-46fa-8519-383f032773b7)(content(Comment\"# \ Internal Regression Tests: Function literal casting \ #\"))))(Secondary((id \ @@ -265,6 +364,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ f2f6342f-640f-40d6-85c7-7d0c5cce62ef)(content(Whitespace\" \ \"))))(Tile((id \ + 1c4f0e25-e566-40e0-ad07-cccd8b647b39)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 6a9756bd-2505-46e0-9493-c1df53e5a1a5)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -276,7 +378,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 5898078f-2261-4a01-ba61-529e85c7a1a8)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 518a4068-d476-4b78-a51d-71da3483d9a4)(content(Whitespace\" \ \")))))))))(Secondary((id \ 7b57f276-9239-48a5-959b-439c645e6b9b)(content(Whitespace\" \ @@ -332,6 +435,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 1d6f9a93-cc2c-4889-a604-f02951053baf)(content(Whitespace\" \ \"))))(Tile((id \ + 72353c4a-4aac-40d9-9812-6d89f7c0dfab)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ bf737c42-1b95-4fea-aed2-763f716782e3)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -343,7 +449,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 25ce4103-1679-4c34-a5f1-5c6930fef1ee)(label(Bool))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ f1c5d99a-e84a-4b86-945a-45eb32da95ba)(content(Whitespace\" \ \")))))))))(Secondary((id \ a3b5cd01-b0a2-4300-ab04-fd6940ffcd15)(content(Whitespace\" \ @@ -475,6 +582,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 2a5dd54d-d7bd-406b-a6ce-f4b9952398e2)(content(Whitespace\" \ \"))))(Tile((id \ + 536cf73b-5815-4e7a-87bc-0c83bc9e8b63)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 1a1b1421-4293-4126-b66b-d6836f42da81)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -486,7 +596,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 194cfbbc-41e4-4896-9af4-a06fe2ec7c6d)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 95d63e9d-e9d1-432e-9738-bcf398544bed)(content(Whitespace\" \ \")))))))))(Secondary((id \ 1ebcd64c-8de0-4d29-a255-24f923bcc1cd)(content(Whitespace\" \ @@ -551,6 +662,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 8cfb3720-7e6e-448c-b437-04478b3622c3)(content(Whitespace\" \ \"))))(Tile((id \ + af040351-7fb7-494d-9d79-03d8695d11d2)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 4657a01e-d011-4d88-acc3-b9cbb590bc28)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -562,7 +676,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 6a54d4b4-a690-43ee-aaf0-145d5008ac26)(label(Bool))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ c68d5b21-d1fb-4a7a-9cb6-d85c71df5a46)(content(Whitespace\" \ \")))))))))(Secondary((id \ ba51531a-4f3b-494e-8c04-653a784f9c20)(content(Whitespace\" \ @@ -716,6 +831,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ d413d35c-d803-4c02-ac95-e683efd8591a)(content(Whitespace\" \ \"))))(Tile((id \ + 7a8ca67b-0ab3-4828-bf80-cb9ff7a3d1db)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ ebc05c7f-07a0-4b3c-ab67-833e556b156a)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -727,8 +845,9 @@ let startup : PersistentData.t = \"))))(Tile((id \ 23c9a9af-4407-4213-8ea2-455466c46119)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ - 0cde4e0a-98dc-468f-8a44-ba2fea56ed49)(content(Whitespace\" \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ + f578af4f-c865-4061-9b37-72966191cce0)(content(Whitespace\" \ \")))))))))(Secondary((id \ 023ddf1d-110e-4830-aecc-8bc19be454da)(content(Whitespace\" \ \"))))(Tile((id \ @@ -803,6 +922,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 96018f05-2e0a-4eb9-9c97-ec586552a39b)(content(Whitespace\" \ \"))))(Tile((id \ + ee8f8cc7-4dfb-4286-9564-2744d35f7371)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 9572156f-8f54-47f7-8575-424ee16e5525)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -814,7 +936,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 7b932435-b4b5-4226-98ef-0ccf56798d13)(label(Bool))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 4640e4ab-feec-43ec-966a-2024927f31e6)(content(Whitespace\" \ \")))))))))(Secondary((id \ 5e3273a2-cf78-465b-97af-ee302b9ceb26)(content(Whitespace\" \ @@ -968,6 +1091,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ de4d1d1e-a36a-447c-b4a7-b6d388726378)(content(Whitespace\" \ \"))))(Tile((id \ + 1143d160-e678-4bf6-9cd1-ab0e0d0310f0)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ e705d8a6-48de-40ac-bf4e-4a993716e2f5)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -979,7 +1105,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 1d95e5e3-df69-4520-99af-3d7ddf297ae8)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 086964f8-ab1a-46c6-9f7b-9e1dbc607452)(content(Whitespace\" \ \")))))))))(Secondary((id \ a11341f9-b8a9-44e5-a04c-2579378cfd2b)(content(Whitespace\" \ @@ -1055,6 +1182,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ a98e10cf-083b-4fd2-b1d0-8b48158594d4)(content(Whitespace\" \ \"))))(Tile((id \ + 52466e27-2c81-4583-aad7-3c9a1f959784)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 8304c105-574b-4ff2-8bd0-49ec6fff1ab1)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -1066,7 +1196,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 9aa05c03-3d06-4fbf-be2a-4e108738f262)(label(Bool))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 03545f59-d1d0-458e-a76c-2f1b3b7f597d)(content(Whitespace\" \ \")))))))))(Secondary((id \ 27cdcb58-f75e-4d2c-8eaf-bbba044374d4)(content(Whitespace\" \ @@ -1220,6 +1351,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 399a8732-ec09-49cf-a7f8-8328d63f0286)(content(Whitespace\" \ \"))))(Tile((id \ + 6744353a-7a04-417a-906e-85faf141796d)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ f90f910d-d864-4376-bba1-541c48e7d7b3)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -1231,7 +1365,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 161cc43e-ec94-429e-b91b-c19ba5b78531)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 150ae360-22f9-404a-89d0-5e3ff3b04a35)(content(Whitespace\" \ \")))))))))(Secondary((id \ 9483c348-a09b-47fc-a3df-0ac8e8b889d3)(content(Whitespace\" \ @@ -1307,6 +1442,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ e502e437-a087-4576-8436-27f3213a2cd6)(content(Whitespace\" \ \"))))(Tile((id \ + 1273f160-7a32-4727-9051-93f50123e588)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ a6f283b2-c95d-49bd-a8dd-55947e2a1270)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -1318,7 +1456,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 3b819b9d-669e-4d1f-ad5e-fd2dfce7f12d)(label(Bool))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 35c887e9-f52e-47d9-8121-4be61869454c)(content(Whitespace\" \ \")))))))))(Secondary((id \ 3b036e98-60cf-472a-9e8f-01c5ced8a8d8)(content(Whitespace\" \ @@ -1472,6 +1611,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ cfe6deae-c503-4c4e-9874-641c1c4799a4)(content(Whitespace\" \ \"))))(Tile((id \ + f16ea864-8b0a-4525-98e6-ad459583991c)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ fea62697-8566-4e39-b7e0-ff85c2769357)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -1483,7 +1625,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 954ca980-5411-4dbe-b228-00efb66fa054)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 47fcc2af-ae97-4341-ad02-a256b2b8d307)(content(Whitespace\" \ \")))))))))(Secondary((id \ d517deff-6469-4b0a-811c-b247359750de)(content(Whitespace\" \ @@ -1559,6 +1702,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 4386035e-5010-4d2a-a56b-8e369cdab53a)(content(Whitespace\" \ \"))))(Tile((id \ + 29a9e9d9-2c3a-4c83-99c8-f8db4b762da3)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ f942974a-343d-4802-869d-424f82da3f92)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -1570,7 +1716,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 7c14bc9e-7371-4820-898a-f282d3fded38)(label(Bool))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 860fc3fc-2ce5-4f94-bcd4-5309e35d21ca)(content(Whitespace\" \ \")))))))))(Secondary((id \ 656d2c3a-adba-4440-b19a-e9f1aba703c7)(content(Whitespace\" \ @@ -1701,6 +1848,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ f91d5a37-ad48-4e6b-a7d0-f13200591773)(content(Whitespace\" \ \"))))(Tile((id \ + 82041fe2-491e-4170-9bb7-c1dec913b8b2)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 2795203d-0717-4c13-82b0-eaaa6adc142e)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -1712,7 +1862,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ f38402bc-8b52-4db6-a19d-92b4b9fd6be2)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ f73c851c-7dd6-471f-bbfe-7c6a2cfb9626)(content(Whitespace\" \ \")))))))))(Secondary((id \ f5862777-feaa-4502-8c3c-aada463eeb74)(content(Whitespace\" \ @@ -1780,6 +1931,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ d8bacea6-3902-4f36-9f8a-16b330e76f73)(content(Whitespace\" \ \"))))(Tile((id \ + 41e2f020-e05c-48c1-ae48-d3c7cb27c98a)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 569f3650-bbe5-4ec7-a48a-f53f2fa1df28)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -1791,7 +1945,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 3e5b1891-31e8-44f6-ae80-c795b070ddc8)(label(Bool))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 8f851483-70b6-4f2d-925a-57a982bfa93d)(content(Whitespace\" \ \")))))))))(Secondary((id \ 63302d7d-1590-4836-ae8d-ca087abdc208)(content(Whitespace\" \ @@ -1947,6 +2102,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 326534a0-3d18-4833-a6d5-c0858a771841)(content(Whitespace\" \ \"))))(Tile((id \ + c2538401-9958-49bd-9f12-3b2ba9b48aec)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 6e703dd6-b924-4ac5-a880-a2ed7b9f4881)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -1958,7 +2116,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ d4a163e4-32d4-489b-a8e4-7c6d24447c05)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 95ec139b-f320-41a8-a7b1-2ce340b5ad26)(content(Whitespace\" \ \")))))))))(Secondary((id \ 04807fbe-1bc7-4bf3-b615-6c68a47735d3)(content(Whitespace\" \ @@ -2035,6 +2194,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ efdef946-6b3a-4762-a4d9-abbd2d2ec7f4)(content(Whitespace\" \ \"))))(Tile((id \ + e72de1d7-0573-4666-996e-1344089064c3)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ dd40d17f-eaca-40f3-800d-fa71f6511717)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -2046,7 +2208,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ b5da4155-cf8b-4f53-8515-95103d0ff286)(label(Bool))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 06a7485d-848b-453f-868b-b7f176a87ec7)(content(Whitespace\" \ \")))))))))(Secondary((id \ ba271a94-21e3-4364-a8a0-44cf74754fe9)(content(Whitespace\" \ @@ -2224,6 +2387,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 09e3f249-0d35-4992-9e96-442bcf21a0f1)(content(Whitespace\" \ \"))))(Tile((id \ + af51d339-25a9-4e1e-ba83-56b19dadba96)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ f06585d0-5231-43e2-a7ff-47bfb8476b06)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -2235,7 +2401,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 2c6324e9-7640-4b34-9ccc-777428a6a097)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ d05188c6-65a0-4faf-bd90-87e61219f6b4)(content(Whitespace\" \ \")))))))))(Secondary((id \ 626c5d8c-9b0a-4eaf-b93e-f2fccc236f33)(content(Whitespace\" \ @@ -2323,6 +2490,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 79c8bf09-f3d0-412e-9d45-baf44eff9bb1)(content(Whitespace\" \ \"))))(Tile((id \ + abd05dc3-d3bc-4fdb-a473-9b91e7307e5b)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 57833b66-cadf-4c0f-b734-35cd0aec89a2)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -2334,7 +2504,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ abb7c9b8-e143-4537-a158-84e720ba8e4d)(label(Bool))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 11a68b18-c9ee-4998-a7a4-3028a8b87bf3)(content(Whitespace\" \ \")))))))))(Secondary((id \ c292d1ba-61d2-42c0-a51f-5e4ed16fd4a6)(content(Whitespace\" \ @@ -2512,6 +2683,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 06ddc928-ab64-4781-bd72-dffab779b785)(content(Whitespace\" \ \"))))(Tile((id \ + fa5203ea-4152-4fb0-9393-de37c04a2581)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ d2319dc5-d1f8-4de0-8d7f-63a147483635)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -2523,7 +2697,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 34769c15-47a8-4e46-aeb5-6eeb8b0807fd)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ a87d5b15-7d32-4daf-abc6-1bcc2b50bd34)(content(Whitespace\" \ \")))))))))(Secondary((id \ c036a747-29d0-4d85-b17b-6d6b56ffadd9)(content(Whitespace\" \ @@ -2611,6 +2786,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 9f7734ab-daaf-4851-b627-af2c546d8b21)(content(Whitespace\" \ \"))))(Tile((id \ + 39554c73-f76c-4495-9048-0a7e06d9e15e)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 78cca49d-e3e1-465a-a32c-6bde6671f2bc)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -2622,7 +2800,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ d6c45d32-a1d2-43b4-8262-6124417d5c86)(label(Bool))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 278e4a58-bc7a-4387-8b49-88616fb2a8cd)(content(Whitespace\" \ \")))))))))(Secondary((id \ ffeace91-a82e-4ef5-85d7-d28c4d9499a1)(content(Whitespace\" \ @@ -2800,6 +2979,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 9eb19b00-2c5d-4fd9-bf10-f824f313a3bd)(content(Whitespace\" \ \"))))(Tile((id \ + 550bbf07-bb40-4c23-8d05-579fc40dbaf6)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ fe3faddd-142f-44a4-a59a-be380e47159e)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -2811,7 +2993,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ fffb4962-d18c-449e-be30-dc73ed7c3a87)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ a406f0cd-29da-4b48-be85-2fae11da87bd)(content(Whitespace\" \ \")))))))))(Secondary((id \ e640fd12-11c1-40ab-92bb-051cdf2a111e)(content(Whitespace\" \ @@ -2899,6 +3082,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 9c0835cf-0fd3-40d4-a82a-db25807291c5)(content(Whitespace\" \ \"))))(Tile((id \ + ce8deaa3-4fe1-4927-b755-8fb31c83d8d5)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 10130787-6c13-47ce-9cc8-8fcd90fac2fe)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -2910,7 +3096,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ ad007c76-3fb0-4aa4-9d46-7092c82c2992)(label(Bool))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 867cf76d-01c2-4ea6-b03d-fd57d631c6a2)(content(Whitespace\" \ \")))))))))(Secondary((id \ 6a6bb12f-d4e7-4071-a134-a6022e4dbaa2)(content(Whitespace\" \ @@ -3088,6 +3275,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 2b02f6d4-2d31-4e60-8cec-6b903fdadae0)(content(Whitespace\" \ \"))))(Tile((id \ + d98ea12f-3be5-475d-8161-edf3ba592859)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 245fb049-2e05-42ec-8fb2-fa3553a1d525)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -3099,7 +3289,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ c15d7c3e-bf3e-44da-8997-2afc9a4ee9a5)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 2ee1898a-0e53-46fd-8c8e-38e670fdd897)(content(Whitespace\" \ \")))))))))(Secondary((id \ cf2250a8-a2b1-4f6c-977f-3614e6b8915d)(content(Whitespace\" \ @@ -3187,6 +3378,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 0ae4fdef-dacb-41a4-b276-37e0efc71965)(content(Whitespace\" \ \"))))(Tile((id \ + 29450694-f79b-430c-a8a2-5a34528fc984)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ da8967f1-c3a1-4f99-ace9-fa4933bfb579)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -3198,7 +3392,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 443b5cb9-1ff9-4aa7-a8a4-fc718f3e9df4)(label(Bool))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 54a22bfc-d43f-4b0b-8d64-199bfe9bba14)(content(Whitespace\" \ \")))))))))(Secondary((id \ 29bbe425-ba82-4208-8c80-2dfa3fd0bee9)(content(Whitespace\" \ @@ -3267,6 +3462,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 0930d78b-5667-4113-9cd1-2889969c1a2d)(content(Whitespace\" \ \"))))(Tile((id \ + 88024995-8540-483a-8e1d-a28077febe5c)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ e7905658-e2e8-4d46-8516-1d1b3c4b41c8)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -3278,7 +3476,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 052c1e66-c99d-437f-9566-8634fac4294b)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ 1cf090b9-5d39-496e-b03d-949f527bdf17)(content(Whitespace\" \ \")))))))))(Secondary((id \ 93e77fef-ef57-49dd-9553-a7b658579d2b)(content(Whitespace\" \ @@ -3343,6 +3542,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 120353f7-949c-4378-b0c3-1fab665fc365)(content(Whitespace\" \ \"))))(Tile((id \ + a77b719e-6796-4707-b3af-e76b1391ef1d)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ a123c1bd-7373-43d3-8c39-4dfde0b58b61)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -3363,7 +3565,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 77134c07-8a4e-4194-8e2f-9a0595c4dd48)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ b07c5dc6-9749-47ba-bec4-a1699f1bfce0)(content(Whitespace\" \ \"))))(Secondary((id \ 2ad38361-9f56-40ed-9291-7bdb46f46385)(content(Whitespace\" \ @@ -3430,6 +3633,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 5589ba00-c0b4-44f1-b2b4-0f6ef87f82f2)(content(Whitespace\" \ \"))))(Tile((id \ + 9b4df7e7-221e-468f-9470-47dde75c1afc)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ e14764ae-97ea-4365-9707-a443a62a56b1)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -3450,7 +3656,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ afe54977-bf81-4824-8206-8843f2658b04)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ f6a23963-e107-48e7-aad0-5f53ce32aee4)(content(Whitespace\" \ \")))))))))(Secondary((id \ 084974bf-38e0-41f1-b64e-9aaa80f602fe)(content(Whitespace\" \ @@ -3515,6 +3722,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ c23ad015-92d8-4d63-9ed4-3557fa6224e7)(content(Whitespace\" \ \"))))(Tile((id \ + 842facff-d306-43c3-9ad9-72f9bb3663f0)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 34ace31f-67fe-46ce-96e4-bdfced8edfac)(label(\"(\"\")\"))(mold((out \ Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ @@ -3551,7 +3761,7 @@ let startup : PersistentData.t = 20623eba-2cda-413a-8c58-1fa4399cea17)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ + Typ))))))(shards(0))(children())))))))))))))(Secondary((id \ 2566dfae-edd4-4ffe-80a4-56968a475285)(content(Whitespace\" \ \")))))))))(Secondary((id \ 52609218-3a2a-4dfd-8f40-0ae4e783a13a)(content(Whitespace\" \ @@ -3625,6 +3835,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 1086b2b9-af49-473e-8e3c-76fc3cb45232)(content(Whitespace\" \ \"))))(Tile((id \ + cacdc273-4ff0-4d64-b345-efb5bae886b3)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ f82c151d-d67a-47d5-88c6-18d79457fc66)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -3636,7 +3849,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ c3151bfb-d7a9-4507-b454-2a77c2fef2a4)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ d0751f56-95dc-4e5a-8142-58b7a9aad3e9)(content(Whitespace\" \ \")))))))))(Secondary((id \ d1594cb6-528c-45b5-9ca0-d2f5db646ebb)(content(Whitespace\" \ @@ -3710,6 +3924,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 931b44f6-bfdd-44a1-9e42-dfb135be1808)(content(Whitespace\" \ \"))))(Tile((id \ + ce7b7591-be66-4313-955b-1b2aea8302d1)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ e35ceb10-6c8f-445e-a055-54028bd61344)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -3717,8 +3934,6 @@ let startup : PersistentData.t = Pat)(in_())(nibs(((shape(Concave 12))(sort \ Pat))((shape(Concave 12))(sort \ Typ))))))(shards(0))(children())))(Secondary((id \ - bf609873-bca2-4b7d-a177-2161e68345ac)(content(Whitespace\" \ - \"))))(Secondary((id \ d03e9b31-6164-4e7d-92f5-cfae09c720b4)(content(Whitespace\" \ \"))))(Tile((id \ 3fc47261-10c6-470c-91ad-2f7b04fbcbf4)(label(?))(mold((out \ @@ -3732,7 +3947,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 742a5e07-30a8-48ab-bd4e-367720619557)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ c95b16bc-5c4e-483f-a9d7-15c0de37a834)(content(Whitespace\" \ \"))))(Secondary((id \ fe78d319-78d2-4072-94c4-68a57926dc7d)(content(Whitespace\" \ @@ -3808,6 +4024,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ bba7f435-d6b1-4c13-a1e8-e36596f8f4a2)(content(Whitespace\" \ \"))))(Tile((id \ + 038f487a-795e-47d3-8f27-c7dec693f9c2)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 24236d9e-31a6-4240-b2df-c0a9aa50a2f0)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -3828,7 +4047,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ ede4f17f-8a4d-4f50-b4f2-7e986d88c2b6)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ 4c547a87-eb59-4fc5-9d19-b23abb75a8d1)(content(Whitespace\" \ \")))))))))(Secondary((id \ bc0a22c9-2204-44ea-8141-7ceaeb09e124)(content(Whitespace\" \ @@ -3902,6 +4122,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ da46c755-ef24-408b-bb62-07524fd24562)(content(Whitespace\" \ \"))))(Tile((id \ + c149459f-6fca-41d0-b263-97a9175a891d)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ a2866d81-aebc-42eb-a7ae-e26043a74cf6)(label(\"(\"\")\"))(mold((out \ Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ @@ -3938,7 +4161,7 @@ let startup : PersistentData.t = d935b558-7c35-46ba-8ec7-58d61f343648)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ + Typ))))))(shards(0))(children())))))))))))))(Secondary((id \ 973270cb-406f-4118-885e-204c4574a814)(content(Whitespace\" \ \")))))))))(Secondary((id \ 1656182a-3530-4fad-b7af-19adeb223861)(content(Whitespace\" \ @@ -4023,6 +4246,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 215728f0-aa5d-43a3-b5b8-8784aad5b8be)(content(Whitespace\" \ \"))))(Tile((id \ + f02c0d01-80ad-4055-971d-a4ef5e1e8018)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 5138bfb3-2dd8-4371-bf07-92df8b84f6d5)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -4034,7 +4260,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ f30751ef-019a-49e3-9a74-ac42e5673b6a)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ 8eb77346-d376-4ea6-ac2b-d428fb0d13bc)(content(Whitespace\" \ \")))))))))(Secondary((id \ 12248498-708f-49ca-97a2-628a1be566f2)(content(Whitespace\" \ @@ -4119,6 +4346,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ b27eb762-a874-4dcc-9fd4-b2b9bd1a9ec8)(content(Whitespace\" \ \"))))(Tile((id \ + 0f421344-f398-4d5b-8243-fdba00cd6264)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ bcd7f101-d67e-458e-b55c-8aa3051f32bb)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -4139,7 +4369,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 9a36f1c2-5edc-4cc7-a74f-a5262554f0f5)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ f28ac6f7-38b2-4450-895a-d0f68f224fd8)(content(Whitespace\" \ \"))))(Secondary((id \ e64b7753-13d6-4874-ab8c-c4eef4c2840c)(content(Whitespace\" \ @@ -4226,6 +4457,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ d407247a-3cd8-4bfb-b03a-ffa207457c0f)(content(Whitespace\" \ \"))))(Tile((id \ + cd230938-f92c-4213-bbf4-30d96105bf9c)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 605c4ae1-95e5-48f6-a0b7-13f9b792a60a)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -4246,7 +4480,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 6fe9f703-34fe-4024-9a4e-334b5548f61f)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ f0eab0f9-ee8a-464c-9ce4-05e0c16b6a84)(content(Whitespace\" \ \")))))))))(Secondary((id \ 92dd92e9-e9d4-4e72-a81d-6c60bbebb5df)(content(Whitespace\" \ @@ -4291,103 +4526,7 @@ let startup : PersistentData.t = Exp)(in_())(nibs(((shape(Concave 16))(sort \ Exp))((shape(Concave 16))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 3822a97c-909e-4e0f-9783-aa511ae2e4be)(content(Whitespace\"\\n\"))))(Tile((id \ - dbc95f6f-0dac-413b-9a57-875c91d1bc19)(label(let = \ - in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 17))(sort Exp))))))(shards(0 1 \ - 2))(children(((Secondary((id \ - 6d4f1f2b-2cb6-4a54-855c-eba41992f09a)(content(Whitespace\" \ - \"))))(Tile((id \ - b2f91c33-d0b4-4a42-8bdd-cb318b160df3)(label(f))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - 3f84fcc2-2c28-4b76-b9c4-7a12a043ddb4)(label(:))(mold((out \ - Pat)(in_())(nibs(((shape(Concave 12))(sort \ - Pat))((shape(Concave 12))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - 849c5444-d52d-407b-a91a-78ecd49eaec7)(content(Whitespace\" \ - \"))))(Tile((id \ - d99c9e74-3821-438c-8a00-2990985f1b27)(label(?))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ - f23c1d14-e2c2-45b8-a766-af783330ef62)(content(Whitespace\" \ - \"))))(Tile((id \ - 3254d589-fc8c-44bd-af59-b32f30bf2194)(label(->))(mold((out \ - Typ)(in_())(nibs(((shape(Concave 5))(sort \ - Typ))((shape(Concave 5))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - 00c77afb-bc00-49a8-8e14-8b24e92793b3)(content(Whitespace\" \ - \"))))(Tile((id \ - cbcd2b8f-95e4-431c-853e-1bd3ebc0c0bd)(label(?))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ - d9b539b4-0ed0-4ce0-a3c4-7c796959d9b2)(content(Whitespace\" \ - \")))))((Secondary((id \ - 005e18cc-6749-4a8d-85f5-513cf98bcbf1)(content(Whitespace\" \ - \"))))(Tile((id \ - b569b6f7-d7fc-4248-b301-16d955623be9)(label(fun \ - ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 14))(sort Exp))))))(shards(0 \ - 1))(children(((Secondary((id \ - e22cb4de-e71f-437c-aa78-7dbddaf539b9)(content(Whitespace\" \ - \"))))(Tile((id \ - f1cf30d1-5648-4a00-ab7f-3a6ddd790203)(label(\"(\"\")\"))(mold((out \ - Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ - 644e9674-214f-4d11-8679-6d3d920cc2ea)(label(a))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - 01fecc9f-f74c-4505-b970-87738e766bd1)(label(,))(mold((out \ - Pat)(in_())(nibs(((shape(Concave 15))(sort \ - Pat))((shape(Concave 15))(sort \ - Pat))))))(shards(0))(children())))(Secondary((id \ - 786d94c1-6e02-4925-b04d-a4a76d0d4e62)(content(Whitespace\" \ - \"))))(Tile((id \ - 2cc9c805-a00e-444f-a440-fbfa3d63c99d)(label(b))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children()))))))))(Tile((id \ - bcada562-fe9c-4f83-acd4-416e41ef4546)(label(:))(mold((out \ - Pat)(in_())(nibs(((shape(Concave 12))(sort \ - Pat))((shape(Concave 12))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - 54b24744-488a-457e-9abf-f70d4947bf8e)(content(Whitespace\" \ - \"))))(Tile((id \ - 14508377-cc9d-420b-8d68-d7d5a7fd35c0)(label(\"(\"\")\"))(mold((out \ - Typ)(in_(Typ))(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0 1))(children(((Tile((id \ - 501dfb3c-f396-46d9-8838-380c842b63e3)(label(Int))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ - 58d2c431-0b68-485f-9fa5-3fbf8823a165)(label(,))(mold((out \ - Typ)(in_())(nibs(((shape(Concave 15))(sort \ - Typ))((shape(Concave 15))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - b8d97744-b2d7-43d6-a0e0-4cb376efb927)(content(Whitespace\" \ - \"))))(Tile((id \ - 8e3dd6c0-0cd8-4006-a23d-ac23094f5564)(label(?))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ - 6cfb4cb5-8066-4a65-b197-b4155ba475f8)(content(Whitespace\" \ - \")))))))))(Secondary((id \ - e547925e-3719-4132-a268-711329c13791)(content(Whitespace\" \ - \"))))(Tile((id \ - f989002e-7cf8-4163-93dd-1043941820c0)(label(a))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - 35b2a690-ccac-466f-b90e-d651f823e56e)(content(Whitespace\" \ - \"))))(Tile((id \ - 18e0b965-1d34-45fd-9a69-9158d8099c33)(label(+))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 6))(sort \ - Exp))((shape(Concave 6))(sort \ - Exp))))))(shards(0))(children())))(Secondary((id \ - b6a82bdb-5fe5-424b-a63c-3edcfb0d08a9)(content(Whitespace\" \ - \"))))(Tile((id \ - b7ed8465-5cd8-45ba-a30c-43f845b03341)(label(1))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - c1b1e3c2-2c9d-46e5-9053-b0d14f2174e7)(content(Whitespace\" \ - \")))))))))(Secondary((id \ + 3822a97c-909e-4e0f-9783-aa511ae2e4be)(content(Whitespace\"\\n\")))))((Secondary((id \ a391afd6-6206-4a8b-9173-eda0124c5248)(content(Whitespace\" \ \"))))(Tile((id \ 04785cf3-a023-4724-b495-a2a5567ff327)(label(f))(mold((out \ @@ -4465,6 +4604,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 15117fe1-bcaf-4b56-9a15-01df91847a3e)(content(Whitespace\" \ \"))))(Tile((id \ + b9d40481-d43b-469b-8d58-cd7d4971af16)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 64bdf45b-3110-4037-9f09-64a644be429d)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -4476,7 +4618,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 3ea5fc7b-03bb-4029-85bf-318eabc68207)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ ef6659b0-9d3c-4018-af64-4c990e77cf00)(content(Whitespace\" \ \")))))))))(Secondary((id \ 94106d2b-323f-485a-a3e1-76c8e0967ac2)(content(Whitespace\" \ @@ -4574,6 +4717,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 07fc34a6-e37e-4af8-9585-d7cac87f19bd)(content(Whitespace\" \ \"))))(Tile((id \ + 57325870-bf4b-4bb9-8b4e-f61f7b3b5b4a)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ c663a1d5-5166-449c-8a8c-f33b63652c5c)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -4594,7 +4740,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 15ef8426-a983-4b8d-ad31-e8dc4695c37c)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ 1eee4812-6300-493c-b91c-8bcdac410000)(content(Whitespace\" \ \")))))))))(Secondary((id \ 9cce1083-a29c-406a-913a-b411aa0a867d)(content(Whitespace\" \ @@ -4692,6 +4839,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 0e9895b8-f3a6-49c3-acb8-ea5973315809)(content(Whitespace\" \ \"))))(Tile((id \ + 7dfbd8f1-b2a1-4f5d-b825-3a2ff7d3c23e)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 019221e7-b7f4-45f6-9cda-eea902b16ccf)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -4712,7 +4862,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ aa33aedf-0177-4014-ba2e-edfc1667b2ec)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ f554b45b-9a88-47f3-a1c5-3aa3b6a6da6e)(content(Whitespace\" \ \")))))))))(Secondary((id \ e8953ff1-37ea-4353-a6f5-13c3edf9f37a)(content(Whitespace\" \ @@ -4808,8 +4959,11 @@ let startup : PersistentData.t = ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 14))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - e5606c6e-7542-4c62-a12d-16ee9db2e3be)(content(Whitespace\" \ + ffb3d65b-da9f-4cbe-9473-70cb93b68144)(content(Whitespace\" \ \"))))(Tile((id \ + 95d5abfd-841b-494d-9792-07a5ef639a6b)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 4bdd36af-3c46-4017-9797-2f2608dbb63b)(label(\"(\"\")\"))(mold((out \ Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ @@ -4846,7 +5000,7 @@ let startup : PersistentData.t = d52e2889-7799-4cb8-b089-dfe46a94a1dd)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ + Typ))))))(shards(0))(children())))))))))))))(Secondary((id \ 97627ef0-8e55-449c-a860-31b892a436ff)(content(Whitespace\" \ \")))))))))(Secondary((id \ 0ce934a9-0108-43fa-9ae7-dd73215f01e3)(content(Whitespace\" \ @@ -4944,6 +5098,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 11439fcd-3a12-45a5-8dc3-eb0e2871a3ba)(content(Whitespace\" \ \"))))(Tile((id \ + 69659dcf-c55b-44f6-a266-3624c44f0aaf)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 0911ba1b-85af-4d18-af1e-1e38c065d78b)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -4955,7 +5112,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 31237158-256a-4be3-af94-c57ec6a1aa59)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ 6f8baedb-6517-4beb-a178-a67a96a39d49)(content(Whitespace\" \ \")))))))))(Secondary((id \ f60f3acd-7836-4436-bcad-f5cedc50aba2)(content(Whitespace\" \ @@ -5053,6 +5211,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 8d3cffdb-352b-4388-8c11-3256fe3eb3c4)(content(Whitespace\" \ \"))))(Tile((id \ + 4700fdb5-cb7a-4435-afe9-3682c54f5aa7)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 5ef11133-5b82-42f5-ab2e-7494af420c15)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -5073,7 +5234,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 1c78e035-6ab3-4094-ad71-99225db45bfa)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ 13e164d8-e802-44e9-bb9d-907681ea2fa6)(content(Whitespace\" \ \"))))(Secondary((id \ 7f5f819a-1111-4679-ad2d-4e8cab62e396)(content(Whitespace\" \ @@ -5173,6 +5335,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ a199017a-a863-44a7-91af-ca4bab16e0c0)(content(Whitespace\" \ \"))))(Tile((id \ + 8911ac75-081d-44ec-a79d-0b001535b9ac)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 1dda4f28-4651-43c4-942f-afc91a06391a)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -5193,7 +5358,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 8c1ae8d6-4e32-4fce-9ba3-1abddb49e7af)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ 90b04bf4-97ce-454a-b7a3-0058ad4148bc)(content(Whitespace\" \ \")))))))))(Secondary((id \ dd298321-2ef3-4941-9f2b-330c29b875ac)(content(Whitespace\" \ @@ -5291,6 +5457,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 27dfc916-18f7-420f-b39b-fe53266910fc)(content(Whitespace\" \ \"))))(Tile((id \ + eb57b65f-4566-48f7-8a98-25aca3f85246)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ f716266b-c8be-4581-b250-984d63b6fbe3)(label(\"(\"\")\"))(mold((out \ Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ @@ -5327,7 +5496,7 @@ let startup : PersistentData.t = 6f8b7845-29d1-4f3f-90ef-4e4044b448d8)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ + Typ))))))(shards(0))(children())))))))))))))(Secondary((id \ 5a427452-2351-440f-bf7f-0a5ba3f2946c)(content(Whitespace\" \ \")))))))))(Secondary((id \ c5ab0cfd-d873-4b9f-9372-3369a86a25fb)(content(Whitespace\" \ @@ -5425,6 +5594,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 70805a22-abdd-42ed-9268-322855c90800)(content(Whitespace\" \ \"))))(Tile((id \ + fa056e19-e2e8-4859-9ef9-d0ab20983b3c)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 35d7bb29-7017-4bca-a2db-253df116efc9)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -5436,7 +5608,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 8ac8c748-7fd3-4a02-805e-5d5323bc696c)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ ce28116e-9e2d-43e9-a793-a53572192803)(content(Whitespace\" \ \")))))))))(Secondary((id \ 8a9e96dc-f7bc-42ff-ba47-01c977440fa2)(content(Whitespace\" \ @@ -5532,8 +5705,11 @@ let startup : PersistentData.t = ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 14))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - c290be37-98df-4e95-8d94-c05467574a74)(content(Whitespace\" \ + 60ce3a90-aa38-4166-ae99-24168c1a2ee8)(content(Whitespace\" \ \"))))(Tile((id \ + acaf9ec1-bb2b-4a16-948f-c05ae6e42692)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ e659ae87-013b-4ba8-a9e7-e1c3ab485a14)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -5554,7 +5730,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 38f13aca-751c-4a31-8092-30fa65d6c0f0)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ 48e1fca6-4927-46e0-89a4-669ead2fd537)(content(Whitespace\" \ \"))))(Secondary((id \ 9d1580b9-18f8-4e36-9b0c-fb724d1fa47c)(content(Whitespace\" \ @@ -5654,6 +5831,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ fe8cd260-7335-4f25-a872-bcac0a6f6d53)(content(Whitespace\" \ \"))))(Tile((id \ + c2c63e16-b169-4cae-8920-a8f1addaab81)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 8cf1949f-c811-4003-9e5d-77f94e4d8744)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -5674,7 +5854,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 2f81ff0c-b8db-4ab1-8c1b-fc4d56647e1c)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ 121d598a-d31d-475f-8c82-280c804713f1)(content(Whitespace\" \ \")))))))))(Secondary((id \ e44b06ba-0433-478f-bcf3-3c4d04adec0a)(content(Whitespace\" \ @@ -5772,6 +5953,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ d64d0383-49e4-4bee-8e88-402364ac2bf2)(content(Whitespace\" \ \"))))(Tile((id \ + a343b7f5-8f2e-4a00-8385-253f6ff223af)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 0980686f-33ad-4301-9340-0cce1fe86647)(label(\"(\"\")\"))(mold((out \ Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ @@ -5808,7 +5992,7 @@ let startup : PersistentData.t = efbccf6d-0d8b-478a-a595-1413475959f2)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ + Typ))))))(shards(0))(children())))))))))))))(Secondary((id \ 1c6a2c54-98e3-423f-b2fa-04a0f31c176d)(content(Whitespace\" \ \")))))))))(Secondary((id \ b7e696ee-0072-4504-b813-66ad684ceebd)(content(Whitespace\" \ @@ -5893,6 +6077,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ f99b0538-9b95-42b5-96b4-15afb3485b66)(content(Whitespace\" \ \"))))(Tile((id \ + 9905e2f1-587c-43d4-9342-02bae52f3b02)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ bd3a7a7f-89c7-4c87-a0f4-b200c691d177)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -5904,7 +6091,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ cef6028f-59f5-4e7d-b194-f7adec478ed8)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ bd1d38d8-0d67-4f80-a35b-59588f1383a7)(content(Whitespace\" \ \")))))))))(Secondary((id \ b5c8eab9-9902-4bd3-a066-8c6c229d14c1)(content(Whitespace\" \ @@ -5989,6 +6177,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ d91f0622-9b52-4b1f-8c5e-cd32d8482079)(content(Whitespace\" \ \"))))(Tile((id \ + a1d9f8df-f002-4611-8f47-229a5d2b18b4)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 117385a4-0f99-4ceb-bd55-e80ccc7eba79)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -6009,7 +6200,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ ed32223d-470f-4237-b2d9-39b0a016a0ac)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ 0fd75c65-531e-4cc9-8f00-30107fab4d69)(content(Whitespace\" \ \"))))(Secondary((id \ b53880b4-4e39-4e65-967c-aa45f62540e4)(content(Whitespace\" \ @@ -6096,6 +6288,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ f18ab206-6397-424f-bd01-8ec1de2af31f)(content(Whitespace\" \ \"))))(Tile((id \ + e6bab5b2-3cb6-43d0-8f19-c8196d99cb0c)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ c54bae36-a6be-45cb-a175-f11b640c14db)(label(a))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ @@ -6116,7 +6311,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ d644270f-ef6e-49e4-84a3-e7cb8fbb4ca7)(label(b))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ 6eb9b226-f651-416f-883c-85365a10311e)(content(Whitespace\" \ \")))))))))(Secondary((id \ 809318ff-8155-415c-8990-23b5fad263c3)(content(Whitespace\" \ @@ -6201,6 +6397,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ 89915481-daa5-42f3-954f-948c1aff1549)(content(Whitespace\" \ \"))))(Tile((id \ + 57596a47-0ea4-4852-aefc-667bde8187e2)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ a53dceac-6fe5-405e-a1d7-97343fbc9030)(label(\"(\"\")\"))(mold((out \ Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ @@ -6237,7 +6436,7 @@ let startup : PersistentData.t = 90c22047-605e-4f41-9b93-d7cd0404ded9)(label(?))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ + Typ))))))(shards(0))(children())))))))))))))(Secondary((id \ d35fea4a-36de-4e10-9512-1873c1965654)(content(Whitespace\" \ \")))))))))(Secondary((id \ 8b51bb9e-3510-4ca9-afaf-579d5e4d05a6)(content(Whitespace\" \ @@ -6282,82 +6481,88 @@ let startup : PersistentData.t = Exp)(in_())(nibs(((shape(Concave 16))(sort \ Exp))((shape(Concave 16))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 5633975f-c769-481e-9b92-68cb2685176c)(content(Whitespace\"\\n\"))))(Grout((id \ - ec5fef77-52f4-4093-a5fa-7e07d30a822b)(shape \ - Convex))))))(ancestors())))(caret Outer))"; + 5633975f-c769-481e-9b92-68cb2685176c)(content(Whitespace\"\\n\"))))(Tile((id \ + c0eec1a4-e61a-4a53-8dfa-3e2dc7ab149e)(label(?))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))(caret(Inner 1 0)))"; backup_text = "# Internal Regression Tests: Function literal casting #\n\ # None of the below should trigger runtime exceptions #\n\n\ let g: ? -> ? = fun _ -> 9 in -g(1);\n\n\ let f = fun b -> b && true in f(true);\n\ - let f = fun b: ? -> b && true in f(true);\n\ - let f = fun b: Bool -> b && true in f(true);\n\ + let f = fun (b: ?) -> b && true in f(true);\n\ + let f = fun (b: Bool) -> b && true in f(true);\n\ let f: ? = fun b -> b && true in f(true);\n\ - let f: ? = fun b: ? -> b && true in f(true);\n\ - let f: ? = fun b: Bool -> b && true in f(true);\n\ + let f: ? = fun (b: ?) -> b && true in f(true);\n\ + let f: ? = fun (b: Bool) -> b && true in f(true);\n\ let f: ? -> ? = fun b -> b && true in f(true);\n\ - let f: ? -> ? = fun b: ? -> b && true in f(true);\n\ - let f: ? -> ? = fun b: Bool -> b && true in f(true);\n\ + let f: ? -> ? = fun (b: ?) -> b && true in f(true);\n\ + let f: ? -> ? = fun (b: Bool) -> b && true in f(true);\n\ let f: Bool -> ? = fun b -> b && true in f(true);\n\ - let f: Bool -> ? = fun b: ? -> b && true in f(true);\n\ - let f: Bool -> ? = fun b: Bool -> b && true in f(true);\n\ + let f: Bool -> ? = fun (b: ?) -> b && true in f(true);\n\ + let f: Bool -> ? = fun (b: Bool) -> b && true in f(true);\n\ let f: Bool -> Bool = fun b -> b && true in f(true);\n\ - let f: Bool -> Bool = fun b: ? -> b && true in f(true);\n\ - let f: Bool -> Bool = fun b: Bool -> b && true in f(true);\n\ + let f: Bool -> Bool = fun (b: ?) -> b && true in f(true);\n\ + let f: Bool -> Bool = fun (b: Bool) -> b && true in f(true);\n\ let f: ? -> Bool = fun b -> b && true in f(true);\n\ - let f: ? -> Bool = fun b: ? -> b && true in f(true);\n\ - let f: ? -> Bool = fun b: Bool -> b && true in f(true); #ERR#\n\n\ + let f: ? -> Bool = fun (b: ?) -> b && true in f(true);\n\ + let f: ? -> Bool = fun (b: Bool) -> b && true in f(true); \ + #ERR#\n\n\ let f = fun b -> b && true in f(true) && true;\n\ - let f = fun b: ? -> b && true in f(true) && true;\n\ - let f = fun b: Bool -> b && true in f(true) && true;\n\ + let f = fun (b: ?) -> b && true in f(true) && true;\n\ + let f = fun (b: Bool) -> b && true in f(true) && true;\n\ let f: ? = fun b -> b && true in f(true) && true;\n\ - let f: ? = fun b: ? -> b && true in f(true) && true;\n\ - let f: ? = fun b: Bool -> b && true in f(true) && true;\n\ + let f: ? = fun (b: ?) -> b && true in f(true) && true;\n\ + let f: ? = fun (b: Bool) -> b && true in f(true) && true;\n\ let f: ? -> ? = fun b -> b && true in f(true) && true;\n\ - let f: ? -> ? = fun b: ? -> b && true in f(true) && true;\n\ - let f: ? -> ? = fun b: Bool -> b && true in f(true) && true;\n\ + let f: ? -> ? = fun (b: ?) -> b && true in f(true) && true;\n\ + let f: ? -> ? = fun (b: Bool) -> b && true in f(true) && true;\n\ let f: Bool -> ? = fun b -> b && true in f(true) && true;\n\ - let f: Bool -> ? = fun b: ? -> b && true in f(true) && true;\n\ - let f: Bool -> ? = fun b: Bool -> b && true in f(true) && true;\n\ + let f: Bool -> ? = fun (b: ?) -> b && true in f(true) && true;\n\ + let f: Bool -> ? = fun (b: Bool) -> b && true in f(true) && \ + true;\n\ let f: Bool -> Bool = fun b -> b && true in f(true) && true;\n\ - let f: Bool -> Bool = fun b: ? -> b && true in f(true) && true;\n\ - let f: Bool -> Bool = fun b: Bool -> b && true in f(true) && \ + let f: Bool -> Bool = fun (b: ?) -> b && true in f(true) && \ true;\n\ + let f: Bool -> Bool = fun (b: Bool) -> b && true in f(true) \ + && true;\n\ let f: ? -> Bool = fun b -> b && true in f(true) && true;\n\ - let f: ? -> Bool = fun b: ? -> b && true in f(true) && true;\n\ - let f: ? -> Bool = fun b: Bool -> b && true in f(true) && \ + let f: ? -> Bool = fun (b: ?) -> b && true in f(true) && true;\n\ + let f: ? -> Bool = fun (b: Bool) -> b && true in f(true) && \ true;\n\n\ - let f = fun a, b -> a + 1 in f(1, 2);\n\ - let f = fun a: ?, b -> a + 1 in f(1, 2);\n\ - let f = fun a: Int, b -> a + 1 in f(1, 2);\n\ - let f = fun (a, b): (Int, ?) -> a + 1 in f(1, 2);\n\ - let f: ? = fun a, b -> a + 1 in f(1, 2);\n\ - let f: ? = fun a: ?, b -> a + 1 in f(1, 2);\n\ - let f: ? = fun a: Int, b -> a + 1 in f(1, 2);\n\ - let f: ? = fun (a, b): (Int, ?) -> a + 1 in f(1, 2);\n\ - let f: ? -> ? = fun a, b -> a + 1 in f(1, 2);\n\ - let f: ? -> ? = fun a: ?, b -> a + 1 in f(1, 2);\n\ - let f: ? -> ? = fun a: Int, b -> a + 1 in f(1, 2);\n\ - let f: ? -> ? = fun (a, b): (Int, ?) -> a + 1 in f(1, 2);\n\ - let f: (?, ?) -> ? = fun a, b -> a + 1 in f(1, 2);\n\ - let f: (?, ?) -> ? = fun a: ?, b -> a + 1 in f(1, 2);\n\ - let f: (?, ?) -> ? = fun a: Int, b -> a + 1 in f(1, 2);\n\ - let f: (?, ?) -> ? = fun (a, b): (Int, ?) -> a + 1 in f(1, 2);\n\ - let f: (Int, ?) -> ? = fun a, b -> a + 1 in f(1, 2);\n\ - let f: (Int, ?) -> ? = fun a: ?, b -> a + 1 in f(1, 2);\n\ - let f: (Int, ?) -> ? = fun a: Int, b -> a + 1 in f(1, 2);\n\ - let f: (Int, ?) -> ? = fun (a, b): (Int, ?) -> a + 1 in f(1, \ + let f = fun (a, b) -> a + 1 in f(1, 2);\n\ + let f = fun (a: ?, b) -> a + 1 in f(1, 2);\n\ + let f = fun (a: Int, b) -> a + 1 in f(1, 2);\n\ + let f = fun ((a, b): (Int, ?)) -> a + 1 in f(1, 2);\n\ + let f: ? = fun (a, b) -> a + 1 in f(1, 2);\n\ + let f: ? = fun (a: ?, b) -> a + 1 in f(1, 2);\n\ + let f: ? = fun (a: Int, b) -> a + 1 in f(1, 2);\n\ + let f: ? = fun ((a, b): (Int, ?)) -> a + 1 in f(1, 2);\n\ + let f: ? -> ? = fun (a, b) -> a + 1 in f(1, 2);\n\ + let f: ? -> ? = fun (a: ?, b) -> a + 1 in f(1, 2);\n\ + let f: ? -> ? = fun (a: Int, b) -> a + 1 in f(1, 2);\n\ + let f: ? -> ? = fun ((a, b): (Int, ?)) -> a + 1 in f(1, 2);\n\ + let f: (?, ?) -> ? = fun (a, b) -> a + 1 in f(1, 2);\n\ + let f: (?, ?) -> ? = fun (a: ?, b) -> a + 1 in f(1, 2);\n\ + let f: (?, ?) -> ? = fun (a: Int, b) -> a + 1 in f(1, 2);\n\ + let f: (?, ?) -> ? = fun ((a, b): (Int, ?)) -> a + 1 in f(1, \ 2);\n\ - let f: (Int, ?) -> Int = fun a, b -> a + 1 in f(1, 2);\n\ - let f: (Int, ?) -> Int = fun a: ?, b -> a + 1 in f(1, 2);\n\ - let f: (Int, ?) -> Int = fun a: Int, b -> a + 1 in f(1, 2);\n\ - let f: (Int, ?) -> Int = fun (a, b): (Int, ?) -> a + 1 in \ + let f: (Int, ?) -> ? = fun (a, b) -> a + 1 in f(1, 2);\n\ + let f: (Int, ?) -> ? = fun (a: ?, b) -> a + 1 in f(1, 2);\n\ + let f: (Int, ?) -> ? = fun (a: Int, b) -> a + 1 in f(1, 2);\n\ + let f: (Int, ?) -> ? = fun ((a, b): (Int, ?)) -> a + 1 in \ f(1, 2);\n\ - let f: ? -> Int = fun a, b -> a + 1 in f(1, 2);\n\ - let f: ? -> Int = fun a: ?, b -> a + 1 in f(1, 2);\n\ - let f: ? -> Int = fun a: Int, b -> a + 1 in f(1, 2);\n\ - let f: ? -> Int = fun (a, b): (Int, ?) -> a + 1 in f(1, 2);\n\ - \ "; + let f: (Int, ?) -> Int = fun (a, b) -> a + 1 in f(1, 2);\n\ + let f: (Int, ?) -> Int = fun (a: ?, b) -> a + 1 in f(1, 2);\n\ + let f: (Int, ?) -> Int = fun (a: Int, b) -> a + 1 in f(1, 2);\n\ + let f: (Int, ?) -> Int = fun ((a, b): (Int, ?)) -> a + 1 in \ + f(1, 2);\n\ + let f: ? -> Int = fun (a, b) -> a + 1 in f(1, 2);\n\ + let f: ? -> Int = fun (a: ?, b) -> a + 1 in f(1, 2);\n\ + let f: ? -> Int = fun (a: Int, b) -> a + 1 in f(1, 2);\n\ + let f: ? -> Int = fun ((a, b): (Int, ?)) -> a + 1 in f(1, 2);\n\ + ?"; } ); ( "ADT Statics", { @@ -8586,7 +8791,7 @@ let startup : PersistentData.t = { zipper = "((selection((focus Left)(content())(mode \ - Normal)))(backpack())(relatives((siblings(()((Secondary((id \ + Normal)))(backpack())(relatives((siblings(((Secondary((id \ 4b993118-7181-44f4-9ebc-5135577cb42e)(content(Comment\"# \ Hazel Language Quick Reference #\"))))(Secondary((id \ 3d39cc52-4179-4dbd-8d7f-8444c8c48de9)(content(Whitespace\"\\n\"))))(Secondary((id \ @@ -9567,7 +9772,7 @@ let startup : PersistentData.t = Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ 2d93c6d9-b12d-472d-92b8-92755566f498)(content(Whitespace\" \ - \")))))))))(Secondary((id \ + \"))))))))))((Secondary((id \ 5a477805-8d4f-48f6-a1d1-556f8e0705e1)(content(Whitespace\"\\n\"))))(Secondary((id \ 8b560c77-4eae-484a-b217-8f82452831ac)(content(Whitespace\"\\n\"))))(Secondary((id \ af3f9a0b-059a-4971-9dfd-73220377bc27)(content(Comment\"# \ @@ -10808,6 +11013,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ c2d33445-f140-4439-b196-943bfdec984c)(content(Whitespace\" \ \"))))(Tile((id \ + ac7c0b83-59d5-4aba-a3b2-2fa641f5c682)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ deb78d0c-a374-4aab-b607-418f29edb496)(label(x))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ @@ -10821,7 +11029,8 @@ let startup : PersistentData.t = \"))))(Tile((id \ 4d92252e-61d0-40e4-8547-22e47a698429)(label(a))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ 2de896ed-0d18-4f4d-aa77-7d510d8768dc)(content(Whitespace\" \ \")))))))))(Secondary((id \ c0fef234-fa75-47c9-82d3-1a0c9bf8d023)(content(Whitespace\" \ @@ -10994,6 +11203,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ bf8c1296-c5b2-47bd-aaa7-7fffba6ee704)(content(Whitespace\" \ \"))))(Tile((id \ + 5d7858a8-c6df-4cc5-8c7f-e3ce3d9303f4)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ f805684a-dbaf-446c-b3e4-e82df0f3be2a)(label(f))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ @@ -11036,7 +11248,7 @@ let startup : PersistentData.t = adec6372-6b9f-4b06-a110-a44bf6893be9)(label(c))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ + Typ))))))(shards(0))(children())))))))))))))(Secondary((id \ b1768b90-841e-4086-886f-7cfffca7608e)(content(Whitespace\" \ \")))))))))(Secondary((id \ 42d489f1-bfad-4ed3-b692-dd6778a3115d)(content(Whitespace\"\\n\"))))(Tile((id \ @@ -11204,6 +11416,9 @@ let startup : PersistentData.t = 1))(children(((Secondary((id \ c21302a8-fa84-488a-956b-68fd8b7bcec7)(content(Whitespace\" \ \"))))(Tile((id \ + e0e89da8-3f21-435e-86af-f066d61c714d)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ 4068a812-3167-4a70-826b-20452a73daca)(label(l))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ @@ -11221,7 +11436,7 @@ let startup : PersistentData.t = d07ac1be-ed43-4913-9366-a1915e538ead)(label(a))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ + Typ))))))(shards(0))(children())))))))))))))(Secondary((id \ 84355a32-6df4-4ebe-a314-cfc652e51f69)(content(Whitespace\" \ \")))))))))(Secondary((id \ 916ecce0-82a7-4c4d-a29d-7d41986b2086)(content(Whitespace\"\\n\"))))(Tile((id \ @@ -11545,17 +11760,17 @@ let startup : PersistentData.t = in\n\n\ # Polymorphic Functions #\n\ let poly_id: forall a -> a -> a =\n\ - typfun a -> fun x : a -> x \n\ + typfun a -> fun (x : a) -> x \n\ in\n\ let apply_both:\n\ forall a -> forall b -> (forall c -> c -> c) -> ((a, b) -> \ (a, b)) =\n\ typfun a -> typfun b ->\n\ - fun f : forall c -> (c -> c) ->\n\ + fun (f : forall c -> (c -> c)) ->\n\ fun (x, y) : (a, b) -> (f@(x), f@(y)) \n\ in\n\ let list_length: forall a -> [a] -> Int =\n\ - typfun a -> fun l : [a] ->\n\ + typfun a -> fun (l : [a]) ->\n\ case l\n\ | [] => 0\n\ | hd::tl => 1 + list_length@(tl) \n\ @@ -11572,7 +11787,52 @@ let startup : PersistentData.t = { zipper = "((selection((focus Left)(content())(mode \ - Normal)))(backpack())(relatives((siblings(()((Secondary((id \ + Normal)))(backpack())(relatives((siblings(((Secondary((id \ + e614e364-e221-402f-8556-50e8caf3b940)(content(Whitespace\" \ + \")))))((Projector((id \ + 2b8a4030-bf70-47b6-8546-4cbe256e5cae)(kind \ + Info)(syntax(Grout((id \ + 2b8a4030-bf70-47b6-8546-4cbe256e5cae)(shape Convex))))(model \ + Expected)))(Secondary((id \ + b6c9f4cd-120e-471a-8874-24b43aab5df9)(content(Whitespace\" \ + \")))))))(ancestors((((id \ + 844dec42-9f30-4750-ac38-a51b56142ee3)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 17))(sort Exp))))))(shards((0 \ + 1)(2)))(children((((Secondary((id \ + 7bb8fe9e-04a0-4ee7-9d36-4a31dfd14c05)(content(Whitespace\" \ + \"))))(Tile((id \ + 1865a79f-c653-44f5-8081-ce2c140f2d80)(label(folds))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ + e819a137-478c-4ba7-9085-f4cbc8335c7d)(label(:))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 12))(sort \ + Pat))((shape(Concave 12))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + d67fb96f-9d3f-4488-b4d9-2a59566cc091)(content(Whitespace\" \ + \"))))(Projector((id \ + 68602b6d-43bb-402b-9a24-bf990bf1c22c)(kind \ + Fold)(syntax(Tile((id \ + 68602b6d-43bb-402b-9a24-bf990bf1c22c)(label(\"(\"\")\"))(mold((out \ + Typ)(in_(Typ))(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0 1))(children(((Tile((id \ + d4f45557-5d33-4376-aacb-21c1e9a1f0b4)(label(Int))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + ec4942d0-661e-4086-8ca7-8b076abb5813)(content(Whitespace\" \ + \"))))(Tile((id \ + 1ec7773a-82e6-4fae-aa59-4762e198c98a)(label(->))(mold((out \ + Typ)(in_())(nibs(((shape(Concave 6))(sort \ + Typ))((shape(Concave 6))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + a89b1307-c340-4055-9a7a-17d319ac6fcd)(content(Whitespace\" \ + \"))))(Tile((id \ + 54bf5314-84f6-4701-bc2a-008fc9485ee2)(label(Bool))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort \ + Typ))))))(shards(0))(children())))))))))(model\"()\")))(Secondary((id \ + c3061b0b-9b43-4426-b14f-2f08c245f300)(content(Whitespace\" \ + \"))))))())))(((Secondary((id \ c3fe923c-f1b5-4fe4-91f3-1920083a48fd)(content(Comment\"# \ PROJECTORS #\"))))(Secondary((id \ 82e9ab71-8f1a-473b-8719-bca4ac1abb73)(content(Whitespace\"\\n\"))))(Secondary((id \ @@ -11671,64 +11931,19 @@ let startup : PersistentData.t = Click to toggle inferred & synthesized types \ #\"))))(Secondary((id \ 83092344-09b3-4027-b669-02cd44e7e379)(content(Whitespace\"\\n\"))))(Secondary((id \ - c2c02009-b47d-4948-8679-da0ed059a6d2)(content(Whitespace\"\\n\"))))(Tile((id \ - 844dec42-9f30-4750-ac38-a51b56142ee3)(label(let = \ - in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 17))(sort Exp))))))(shards(0 1 \ - 2))(children(((Secondary((id \ - 7bb8fe9e-04a0-4ee7-9d36-4a31dfd14c05)(content(Whitespace\" \ - \"))))(Tile((id \ - 1865a79f-c653-44f5-8081-ce2c140f2d80)(label(folds))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - e819a137-478c-4ba7-9085-f4cbc8335c7d)(label(:))(mold((out \ - Pat)(in_())(nibs(((shape(Concave 12))(sort \ - Pat))((shape(Concave 12))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - d67fb96f-9d3f-4488-b4d9-2a59566cc091)(content(Whitespace\" \ - \"))))(Projector((id \ - 68602b6d-43bb-402b-9a24-bf990bf1c22c)(kind \ - Fold)(syntax(Tile((id \ - 68602b6d-43bb-402b-9a24-bf990bf1c22c)(label(\"(\"\")\"))(mold((out \ - Typ)(in_(Typ))(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0 1))(children(((Tile((id \ - d4f45557-5d33-4376-aacb-21c1e9a1f0b4)(label(Int))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ - ec4942d0-661e-4086-8ca7-8b076abb5813)(content(Whitespace\" \ - \"))))(Tile((id \ - 1ec7773a-82e6-4fae-aa59-4762e198c98a)(label(->))(mold((out \ - Typ)(in_())(nibs(((shape(Concave 6))(sort \ - Typ))((shape(Concave 6))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - a89b1307-c340-4055-9a7a-17d319ac6fcd)(content(Whitespace\" \ - \"))))(Tile((id \ - 54bf5314-84f6-4701-bc2a-008fc9485ee2)(label(Bool))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort \ - Typ))))))(shards(0))(children())))))))))(model\"()\")))(Secondary((id \ - c3061b0b-9b43-4426-b14f-2f08c245f300)(content(Whitespace\" \ - \")))))((Secondary((id \ - e614e364-e221-402f-8556-50e8caf3b940)(content(Whitespace\" \ - \"))))(Projector((id \ - 2b8a4030-bf70-47b6-8546-4cbe256e5cae)(kind \ - Info)(syntax(Grout((id \ - 2b8a4030-bf70-47b6-8546-4cbe256e5cae)(shape Convex))))(model \ - Expected)))(Secondary((id \ - b6c9f4cd-120e-471a-8874-24b43aab5df9)(content(Whitespace\" \ - \")))))))))(Secondary((id \ - df00c631-b6c1-42ba-b179-22bfbe078fcd)(content(Whitespace\"\\n\"))))(Secondary((id \ - eb6977fb-0298-4bd6-8106-515bf6274105)(content(Whitespace\"\\n\"))))(Secondary((id \ - a46616c8-f52b-4755-9bf1-e1a324298a9a)(content(Comment\"# \ - Projectors on literal data are called livelits. \ - #\"))))(Secondary((id \ - c507ba49-0c28-49ba-ab08-be00b86f7cfe)(content(Whitespace\"\\n\"))))(Secondary((id \ - 7c56f9a4-5c09-4a53-952d-9261a9f17ec8)(content(Comment\"# \ - Three base types literals use inline views: \ - #\"))))(Secondary((id \ - 5bd865da-3375-478d-9b93-1d4861cb6a22)(content(Whitespace\"\\n\"))))(Secondary((id \ - a58a0cc6-4614-440c-8093-c54b3d3b19c2)(content(Whitespace\"\\n\"))))(Tile((id \ - c2ab8eb6-631f-4976-a9bb-cc92eca07f78)(label(let = \ + c2c02009-b47d-4948-8679-da0ed059a6d2)(content(Whitespace\"\\n\")))))((Secondary((id \ + df00c631-b6c1-42ba-b179-22bfbe078fcd)(content(Whitespace\"\\n\"))))(Secondary((id \ + eb6977fb-0298-4bd6-8106-515bf6274105)(content(Whitespace\"\\n\"))))(Secondary((id \ + a46616c8-f52b-4755-9bf1-e1a324298a9a)(content(Comment\"# \ + Projectors on literal data are called livelits. \ + #\"))))(Secondary((id \ + c507ba49-0c28-49ba-ab08-be00b86f7cfe)(content(Whitespace\"\\n\"))))(Secondary((id \ + 7c56f9a4-5c09-4a53-952d-9261a9f17ec8)(content(Comment\"# \ + Three base types literals use inline views: \ + #\"))))(Secondary((id \ + 5bd865da-3375-478d-9b93-1d4861cb6a22)(content(Whitespace\"\\n\"))))(Secondary((id \ + a58a0cc6-4614-440c-8093-c54b3d3b19c2)(content(Whitespace\"\\n\"))))(Tile((id \ + c2ab8eb6-631f-4976-a9bb-cc92eca07f78)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 17))(sort Exp))))))(shards(0 1 \ 2))(children(((Secondary((id \ @@ -12177,8 +12392,7 @@ let startup : PersistentData.t = \"))))(Tile((id \ 671dc1bb-b869-4ed2-b37c-76cbfa69df25)(label(box))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort \ - Exp))))))(shards(0))(children()))))))(ancestors())))(caret \ + Convex)(sort Exp))))))(shards(0))(children()))))))))))(caret \ Outer))"; backup_text = "# PROJECTORS #\n\n\ @@ -12189,26 +12403,26 @@ let startup : PersistentData.t = # Fold projectors cover terms with abstractions. #\n\ # 1. A simple fold roles up any term, replacing #\n\ # it with ... until it is expanded again. #\n\n\ - let fold = in\n\n\ + let fold = (((((((((((()))))))))))) in\n\n\ # 2. A semantic fold covers a term with a property: #\n\ # Click to toggle inferred & synthesized types #\n\n\ - let folds: = in\n\n\ + let folds: (Int -> Bool) = in\n\n\ # Projectors on literal data are called livelits. #\n\ # Three base types literals use inline views: #\n\n\ - let guard: Bool = in\n\ - let phase: Int = in\n\ - let float: Float = in\n\n\ + let guard: Bool = true in\n\ + let phase: Int = 44 in\n\ + let float: Float = 79.00 in\n\n\ # Inline error decorations (same as for tokens) #\n\n\ - let (a:Int, f: Float) = , in\n\n\ + let (a:Int, f: Float) = true, 28 in\n\n\ # The String base type get a multiline view: #\n\n\ - let _ = in\n\ - let __ = in\n\ - let ___ = in\n\ - let ____ = in\n\ - let _____ = in\n\ - let ______ = in\n\n\ + let _ = \"\" in\n\ + let __ = \"\\n\" in\n\ + let ___ = \"a\" in\n\ + let ____ = \"shift\\n\" in\n\ + let _____ = \"\\nmalicious\" in\n\ + let ______ = \"a\\n shift\\n malicious\" in\n\n\ # Multiline error decorations #\n\n\ - let box: Int = in\n\n\ + let box: Int = \"\\nmalicious\" in\n\n\ # ERRATA: #\n\ # The bottom toggle can also be used to remove #\n\ # projectors. Currently only bidelmited terms can #\n\ @@ -12217,7 +12431,7 @@ let startup : PersistentData.t = # currently are lost on cut/copy. Both these #\n\ # restrictions will be removed in a future update. #\n\n\ # Projectors playground #\n\n\ - if && < () \n\ + if true && 23 < int_of_float(51.00) \n\ then ______ else \"its: \" ++ box"; } ); ( "Types & static errors", @@ -14123,447 +14337,287 @@ let startup : PersistentData.t = { zipper = "((selection((focus Left)(content())(mode \ - Normal)))(backpack())(relatives((siblings(()((Secondary((id \ - 579a2658-f19d-496b-83bb-3840422b8218)(content(Comment\"# \ - Lambda Calculus via evaluation by substitution \ - #\"))))(Secondary((id \ - 58d3c269-21cb-4b04-839c-d1e745cd6c9a)(content(Whitespace\"\\n\"))))(Secondary((id \ - b3539b17-f970-4b91-a865-6f442db15e21)(content(Whitespace\"\\n\"))))(Secondary((id \ - 53f9307e-6888-4508-86de-8c15c2a0b734)(content(Comment\"# An \ - Expression is a variable, function, or application \ - #\"))))(Secondary((id \ - c9014d63-730a-4661-b521-6b44ae002db9)(content(Whitespace\"\\n\"))))(Tile((id \ - 3b6f8f45-d98f-453f-815a-57eaf3789cbd)(label(type = \ - in))(mold((out Exp)(in_(TPat Typ))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 17))(sort Exp))))))(shards(0 1 \ - 2))(children(((Secondary((id \ - 904b8eb7-4c19-4abf-8637-740ad6c6186a)(content(Whitespace\" \ - \"))))(Tile((id \ - 66b489b4-bfd2-406f-810e-f47537d21ae6)(label(Exp))(mold((out \ - TPat)(in_())(nibs(((shape Convex)(sort TPat))((shape \ - Convex)(sort \ - TPat))))))(shards(0))(children())))(Secondary((id \ - 6d84ad07-906b-4b91-9aa3-18e606c93cf1)(content(Whitespace\" \ - \")))))((Secondary((id \ - e23cac29-dd75-4613-93c9-77f014f56f31)(content(Whitespace\"\\n\"))))(Tile((id \ - 81ac84c9-29d1-463c-941e-57b267719ff3)(label(+))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape(Concave \ - 11))(sort Typ))))))(shards(0))(children())))(Secondary((id \ - b4a22f35-2ed9-430f-919e-b2ee80cee5bd)(content(Whitespace\" \ - \"))))(Tile((id \ - 8b41055c-70d6-45c2-940f-5c2d826e61db)(label(Var))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ - bb5c65e6-bd07-41b2-a344-a687b0f42718)(label(\"(\"\")\"))(mold((out \ - Typ)(in_(Typ))(nibs(((shape(Concave 2))(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0 1))(children(((Tile((id \ - 6eac0ae4-7b36-443a-88c7-509db5d45436)(label(String))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ - 354cfa7b-69f9-4d5a-83d6-0a2c199a74c3)(content(Whitespace\"\\n\"))))(Tile((id \ - 35331ee6-8a63-44da-9424-40ac844466c4)(label(+))(mold((out \ - Typ)(in_())(nibs(((shape(Concave 11))(sort \ - Typ))((shape(Concave 11))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - 65a261a6-148a-4d37-9ab6-93756a5bc85a)(content(Whitespace\" \ - \"))))(Tile((id \ - e25ed46e-a960-4707-bc68-c0b815371fc1)(label(Lam))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ - 36db6124-df59-471f-94fc-3a309d41252c)(label(\"(\"\")\"))(mold((out \ - Typ)(in_(Typ))(nibs(((shape(Concave 2))(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0 1))(children(((Tile((id \ - 93389af3-f3ed-495b-85cf-3982c385fa1e)(label(String))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ - f32f8b6d-872c-441c-b5f3-77d23dc887e8)(label(,))(mold((out \ - Typ)(in_())(nibs(((shape(Concave 15))(sort \ - Typ))((shape(Concave 15))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - 3f06cf74-6b7d-47c6-b07f-05c09466cc24)(content(Whitespace\" \ - \"))))(Tile((id \ - 82369742-b375-4963-99a3-f73ce9d30508)(label(Exp))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ - 5be3a31d-1b8e-401e-bde0-14ded0a7ff4c)(content(Whitespace\"\\n\"))))(Tile((id \ - 9246efbe-34a1-41f7-92bf-41568937b53a)(label(+))(mold((out \ - Typ)(in_())(nibs(((shape(Concave 11))(sort \ - Typ))((shape(Concave 11))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - 68ef1881-fac3-41c7-99ef-a9243d67551f)(content(Whitespace\" \ - \"))))(Tile((id \ - e8e6e9f3-3788-4813-a8ec-850f7cbe3241)(label(Ap))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ - 2680b9e1-85d9-4910-bfb2-176f29dfa383)(label(\"(\"\")\"))(mold((out \ - Typ)(in_(Typ))(nibs(((shape(Concave 2))(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0 1))(children(((Tile((id \ - 73ed87ff-dd1a-4f71-aa3a-5dd42e15b926)(label(Exp))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ - 442dcc5c-8386-4ec1-bc9f-2685b18ab7d0)(label(,))(mold((out \ - Typ)(in_())(nibs(((shape(Concave 15))(sort \ - Typ))((shape(Concave 15))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - acf2010e-395f-40c6-a340-59ef389a3e49)(content(Whitespace\" \ - \"))))(Tile((id \ - 7e9227bd-8441-4fa9-9c16-024a91a9e513)(label(Exp))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ - 39e00c73-a5a2-4249-a0ae-df55a1f0f6b4)(content(Whitespace\" \ - \")))))))))(Secondary((id \ - c2faba41-d1f2-4720-8245-64f06fc2ce13)(content(Whitespace\"\\n\"))))(Secondary((id \ - 4baf2caa-6b6d-4546-b6a2-0cfa47a86289)(content(Whitespace\"\\n\"))))(Secondary((id \ - 18808867-1152-40f9-ad32-2c142d01d247)(content(Comment\"# \ - Syntatic Equality of Expressions #\"))))(Secondary((id \ - 7b04a7ea-2e9a-45bc-bd28-01ca94ab1ce5)(content(Whitespace\"\\n\"))))(Tile((id \ - 9af020ec-3e6a-42b5-ae4a-4416f5b8141a)(label(let = \ - in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 17))(sort Exp))))))(shards(0 1 \ - 2))(children(((Secondary((id \ - 891fac75-70a7-47a2-ae6c-f264a06875c1)(content(Whitespace\" \ + Normal)))(backpack())(relatives((siblings(((Secondary((id \ + ab4e863d-fe5e-4773-aee7-47ea69e9a81f)(content(Whitespace\"\\n\"))))(Tile((id \ + 219a6daf-2bc5-4d0b-acf0-9dfc2d57fff8)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 14))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + a196a02c-46be-4da2-9762-5c375d09afe7)(content(Whitespace\" \ \"))))(Tile((id \ - e4ca9d4f-8942-4826-9fd7-757ca711a3e2)(label(exp_equal))(mold((out \ + 71fc3e6a-b851-4014-8194-81012a9e6602)(label(v))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - 3505d0bf-0ff7-4e6e-8e69-bb2a191cf4d4)(label(:))(mold((out \ - Pat)(in_())(nibs(((shape(Concave 12))(sort \ - Pat))((shape(Concave 12))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - a497eb20-cf3f-4ef7-b165-45a9e855923a)(content(Whitespace\" \ - \"))))(Tile((id \ - afe12787-4b57-49c8-baed-316afa71c5fc)(label(\"(\"\")\"))(mold((out \ - Typ)(in_(Typ))(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0 1))(children(((Tile((id \ - 192cce66-f0d9-4434-b6d1-7aa733083586)(label(Exp))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ - 8063def0-fde4-4cab-a9c7-fc7b3f962da9)(label(,))(mold((out \ - Typ)(in_())(nibs(((shape(Concave 15))(sort \ - Typ))((shape(Concave 15))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - 7db42639-afc1-4b83-9b03-639d9edb28b3)(content(Whitespace\" \ - \"))))(Tile((id \ - b2dc55fa-30a5-4cc6-84f7-4c46ad679c4e)(label(Exp))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort \ - Typ))))))(shards(0))(children()))))))))(Secondary((id \ - d0a96d6b-dff9-48dd-b423-a5968f7e4aed)(content(Whitespace\" \ - \"))))(Tile((id \ - c1175695-ebd5-427d-92d3-fb22474cc58c)(label(->))(mold((out \ - Typ)(in_())(nibs(((shape(Concave 6))(sort \ - Typ))((shape(Concave 6))(sort \ - Typ))))))(shards(0))(children())))(Secondary((id \ - 770f873e-d093-4861-bee2-11d454695ca5)(content(Whitespace\" \ + 4318d3e7-c631-4b2e-9a7a-0e5bc7898466)(label(,))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 15))(sort \ + Pat))((shape(Concave 15))(sort \ + Pat))))))(shards(0))(children())))(Secondary((id \ + 1abe26ac-ac76-4d60-b72d-4c84b71df926)(content(Whitespace\" \ \"))))(Tile((id \ - ad33920a-601a-4246-9426-7eb90bd7571f)(label(Bool))(mold((out \ - Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ - Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ - 05298787-a73a-43ab-8ffc-1046f3fc8b05)(content(Whitespace\" \ - \")))))((Secondary((id \ - 184629c3-7fad-4f2b-9c53-a74ca7a3d63d)(content(Whitespace\"\\n\"))))(Tile((id \ - 98082679-8cc9-4d38-abe5-4ac6e4cea1cd)(label(fun \ - ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 14))(sort Exp))))))(shards(0 \ - 1))(children(((Secondary((id \ - 9ec23bc0-f548-42a0-b241-aa75d9fa6527)(content(Whitespace\" \ + dc4f1bd4-abc3-4d55-b0ef-3d06e7d3d2f6)(label(name))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ + a1ec902c-e5b7-42e9-b76a-e0f1c1ce1dd4)(label(,))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 15))(sort \ + Pat))((shape(Concave 15))(sort \ + Pat))))))(shards(0))(children())))(Secondary((id \ + f39b26a7-18fa-4d6d-bc10-5a86815b580f)(content(Whitespace\" \ \"))))(Tile((id \ - 689fed0b-30e9-4ca4-8fe6-fda72c60e103)(label(es))(mold((out \ + d0e16c86-d3ec-4e39-98e6-51ab274d8cd1)(label(e))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - 793d6fcd-45b8-4d78-a38e-d3fd69ca38a7)(content(Whitespace\" \ - \")))))))))(Secondary((id \ - 3ac5410d-2711-4db4-9ed1-d65e01c6903b)(content(Whitespace\"\\n\"))))(Tile((id \ - 180d0645-b358-424c-b871-1289619589bc)(label(case \ + e8c29ad7-e1eb-488f-9aab-cb88d6a08484)(content(Whitespace\" \ + \"))))))))))((Secondary((id \ + 3de61dc3-139e-4ce5-b9c4-92c7d6a7a218)(content(Whitespace\"\\n\"))))(Tile((id \ + 9b89f0ba-7886-4803-aa11-c1a693afc3a4)(label(case \ end))(mold((out Exp)(in_(Rul))(nibs(((shape Convex)(sort \ Exp))((shape Convex)(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - 75d98680-2cfe-4d2c-8005-6f770a2c4a58)(content(Whitespace\" \ + 7becd8a7-6c1c-4f2f-9c6a-2637e7284820)(content(Whitespace\" \ \"))))(Tile((id \ - 4d98706e-25e6-4404-bd81-b4c19b19db2d)(label(es))(mold((out \ + 58e8f274-fa5c-4a08-a050-7840beca26df)(label(e))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - cb5d85d8-6c5f-4d35-acf9-2716f96c11fa)(content(Whitespace\"\\n\"))))(Tile((id \ - f018da47-6f03-4d21-9a18-320122d8ce0d)(label(| =>))(mold((out \ + c917b2fc-b1f6-4494-bae7-fdc5d8314ac0)(content(Whitespace\"\\n\"))))(Tile((id \ + ffee5d55-f2d7-4b66-91ca-e199c1eedd44)(label(| =>))(mold((out \ Rul)(in_(Pat))(nibs(((shape(Concave 21))(sort \ Exp))((shape(Concave 21))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - 6c565fa4-0199-4227-aad8-50f82c08dad5)(content(Whitespace\" \ + fa4628a7-b6e2-40a9-912d-9ab2003e66ab)(content(Whitespace\" \ \"))))(Tile((id \ - d6605b32-8436-481e-a4ab-66074fd68305)(label(Var))(mold((out \ + 4f300848-04c1-4d28-a9ac-34cb3d72005c)(label(Var))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - dee86624-d32e-4e70-8edd-d4e7d58d37f7)(label(\"(\"\")\"))(mold((out \ + 5d3a134c-3f74-4fdc-818c-037d3ee533b0)(label(\"(\"\")\"))(mold((out \ Pat)(in_(Pat))(nibs(((shape(Concave 2))(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ - 13b4fe0e-bcaa-4283-8f3f-a0e13dcd40bb)(label(x))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children()))))))))(Tile((id \ - 493926e4-6cbb-44cc-b206-ead1cec82092)(label(,))(mold((out \ - Pat)(in_())(nibs(((shape(Concave 15))(sort \ - Pat))((shape(Concave 15))(sort \ - Pat))))))(shards(0))(children())))(Secondary((id \ - 05377add-3eba-48f8-ada1-26eb74fbc3c0)(content(Whitespace\" \ - \"))))(Tile((id \ - 7945262f-0e83-4a65-a946-bdab7b39424f)(label(Var))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - 8de1adaa-fa8e-48ce-89ac-d903791c65a7)(label(\"(\"\")\"))(mold((out \ - Pat)(in_(Pat))(nibs(((shape(Concave 2))(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ - 322e956e-a064-4731-8ba3-7b5ded46b0b0)(label(y))(mold((out \ + ff0ccc42-3ffd-4432-a1d6-a070e2b6f346)(label(n))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort \ Pat))))))(shards(0))(children()))))))))(Secondary((id \ - 9707713c-a669-437d-9447-58713fb6b8c5)(content(Whitespace\" \ + 1561ab66-303f-4871-9b48-1bcc763a671e)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 482ff6f8-2d76-455d-9a94-a1c09b073eac)(content(Whitespace\" \ + 8b9692ba-3782-4f79-a2e9-2ab485357d4d)(content(Whitespace\"\\n\"))))(Secondary((id \ + 96b3ae46-b8c8-432e-8dce-07b229df5a88)(content(Whitespace\" \ + \"))))(Secondary((id \ + 2f4a7d91-7dc4-4da6-8371-318822592b07)(content(Whitespace\" \ \"))))(Tile((id \ - ab0ffd4a-8d3a-47d8-9149-2d2b96c45204)(label(x))(mold((out \ + 1aedd057-2c2b-455a-a1a2-b5f1e41909e0)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 7738b2b4-d591-4ade-b3b6-f05b1907e6d8)(label(if then \ + else))(mold((out Exp)(in_(Exp Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 13))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + b3306766-434f-425e-bf19-10aeaeec9b99)(content(Whitespace\" \ + \"))))(Tile((id \ + e7d7a06c-4c8d-4852-b69c-2c5a2836c7fb)(label(n))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 309d2d36-e859-448d-a80c-cea3bc9d3454)(label($==))(mold((out \ + 712dad6c-a685-4294-88a3-b79fc2e7950f)(label($==))(mold((out \ Exp)(in_())(nibs(((shape(Concave 9))(sort \ Exp))((shape(Concave 9))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 13d30f0b-ebdb-4498-b392-8aa47b849281)(content(Whitespace\" \ + 87e9ee65-9c06-42ec-acd2-b93b3f777c2f)(content(Whitespace\" \ \"))))(Tile((id \ - 32f78d11-4e5c-4bb8-b663-75936231f228)(label(y))(mold((out \ + f9e3a6fb-5b11-49c7-b219-741d1ccbd526)(label(name))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - a6b02ca9-65a3-423c-8a2d-98b69271daa7)(content(Whitespace\"\\n\"))))(Tile((id \ - 315a9b91-39f1-4001-9c52-3ee45f73989f)(label(| =>))(mold((out \ + 2dc75d3c-7a4f-4b64-9e43-01ac29e2717b)(content(Whitespace\" \ + \")))))((Secondary((id \ + 4683c684-877a-4546-a637-a5a8a03a6822)(content(Whitespace\" \ + \"))))(Tile((id \ + 189fae6c-2558-4681-a09a-1e13f70bb17e)(label(v))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 67ff8509-6b9f-4707-b3a0-63f33fde3378)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 3d008a86-4add-45b4-ae61-6d0c47eb43ad)(content(Whitespace\" \ + \"))))(Tile((id \ + 1fd0007d-1e2e-4149-bf0b-e91bb130fef1)(label(e))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))(Secondary((id \ + ad4f733a-2033-4e4a-992b-25cd79c81ec2)(content(Whitespace\"\\n\"))))(Tile((id \ + 50e8ef28-d17c-4c54-b0a8-20182938f045)(label(| =>))(mold((out \ Rul)(in_(Pat))(nibs(((shape(Concave 21))(sort \ Exp))((shape(Concave 21))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - a6917a08-5b7c-4519-a67d-4ea8a31932a6)(content(Whitespace\" \ - \"))))(Tile((id \ - 58e1ac3f-e659-4372-9510-386d7ebe50f7)(label(Lam))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - 073c5366-7d94-470f-adb5-f383a9eaa4bb)(label(\"(\"\")\"))(mold((out \ - Pat)(in_(Pat))(nibs(((shape(Concave 2))(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ - 9b281aa5-8d06-4714-9cd2-ffab5b0c71ea)(label(x1))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - c618ba26-4a6e-4726-bad5-90f9983e6fe5)(label(,))(mold((out \ - Pat)(in_())(nibs(((shape(Concave 15))(sort \ - Pat))((shape(Concave 15))(sort \ - Pat))))))(shards(0))(children())))(Secondary((id \ - 29339c3b-fb4e-41f4-8cd4-cad7426fa6c1)(content(Whitespace\" \ - \"))))(Tile((id \ - fc86dc77-9c0b-4a37-987a-6b9f83dfcd7f)(label(e1))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children()))))))))(Tile((id \ - be7a697f-0d3f-498c-b036-bed60ec00fdd)(label(,))(mold((out \ - Pat)(in_())(nibs(((shape(Concave 15))(sort \ - Pat))((shape(Concave 15))(sort \ - Pat))))))(shards(0))(children())))(Secondary((id \ - c4083882-1dae-4651-ab52-c9b1c4e7ced1)(content(Whitespace\" \ + 512cb880-2a52-4828-aa7f-c3a497144c27)(content(Whitespace\" \ \"))))(Tile((id \ - 42b509d9-0759-480f-857c-3d82df96e158)(label(Lam))(mold((out \ + fe07cd73-0165-4a4e-963d-10c0851148d6)(label(Lam))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - 02429a5b-fff7-4b42-a5be-9acd44a729fb)(label(\"(\"\")\"))(mold((out \ + 583cd22d-feb9-4699-9d2d-a299de446af4)(label(\"(\"\")\"))(mold((out \ Pat)(in_(Pat))(nibs(((shape(Concave 2))(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ - c76367a5-6ef8-41f5-9599-faf285ff1878)(label(x2))(mold((out \ + 0a213226-4739-4717-b595-5a767c2ac08b)(label(x))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - b7b861e4-22d0-437f-bd2c-95d57d7370fc)(label(,))(mold((out \ + d986e7be-4ba6-4517-ba63-4353fc7a6590)(label(,))(mold((out \ Pat)(in_())(nibs(((shape(Concave 15))(sort \ Pat))((shape(Concave 15))(sort \ Pat))))))(shards(0))(children())))(Secondary((id \ - b7609391-f2ce-4d1e-bbe6-3a25fa099458)(content(Whitespace\" \ + 39255e0e-1274-4798-a161-93c16f0c4f6c)(content(Whitespace\" \ \"))))(Tile((id \ - f3d69f1d-8f6b-4095-a97e-d6e61d97b4b7)(label(e2))(mold((out \ + 9898ec8e-d5bd-4c3f-b3d5-0f068e906326)(label(body))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort \ Pat))))))(shards(0))(children()))))))))(Secondary((id \ - 0e5305cd-0907-4947-87e9-37da9fcc349d)(content(Whitespace\" \ + 6a4ad6e7-d48b-4866-9ace-cbde29edc492)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 143d94d0-7ea4-4f2d-b70e-e23baf9cd31a)(content(Whitespace\"\\n\"))))(Secondary((id \ - d264c081-8f4b-4254-b6a9-de34f5286a6c)(content(Whitespace\" \ + 1b1fd754-1200-4a0a-8df2-27b97617942e)(content(Whitespace\"\\n\"))))(Secondary((id \ + 37fcc3ae-97a7-42f8-b795-90b5305cc46f)(content(Whitespace\" \ \"))))(Secondary((id \ - c9d7e936-7bc6-4e4e-b0c2-ce0e25fa93e7)(content(Whitespace\" \ + 898a6aea-5011-41cb-bda5-c4844285deec)(content(Whitespace\" \ \"))))(Tile((id \ - 34583060-75ce-4137-802e-b2a55ff9645e)(label(x1))(mold((out \ + 4321f0b3-5146-4f8c-9015-3bffaac6537f)(label(Lam))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 8f95d04f-b61b-4abb-8b77-3d8e0d535d88)(label($==))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 9))(sort \ - Exp))((shape(Concave 9))(sort \ - Exp))))))(shards(0))(children())))(Secondary((id \ - 0938c068-c702-468e-b785-cf7004de3ca2)(content(Whitespace\" \ - \"))))(Tile((id \ - f7399b45-070e-47bc-949f-88f0ea9efc49)(label(x2))(mold((out \ + c6f6c21b-6ea5-4ef7-bd60-97755a20b4df)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 2))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 413bd5cb-afce-4a31-bfec-c4c80e708bcb)(label(x))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - 62f423d3-1612-47e6-923e-bbae907e2a35)(content(Whitespace\" \ - \"))))(Tile((id \ - 63b9d6fd-d888-47b4-8364-49366bc74d65)(label(&&))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 10))(sort \ - Exp))((shape(Concave 10))(sort \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 50cb1442-335b-4cd1-b2e4-867579fdaba6)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 15))(sort \ + Exp))((shape(Concave 15))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - cc2ac2c0-43d5-4ce5-a451-18c097e284c4)(content(Whitespace\" \ + 2fe3d96e-0c7c-4011-a604-630ca52de2e6)(content(Whitespace\" \ \"))))(Tile((id \ - 787f8c3c-346c-4f69-a3d8-14f0ea05d731)(label(exp_equal))(mold((out \ + 825ea4de-9981-4dfb-969f-5901d16c14f1)(label(subst))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 70ed7427-b523-4292-9805-08aaca91925a)(label(\"(\"\")\"))(mold((out \ + 06e5576f-8c2a-494c-84f0-e6c44b6fc289)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 2))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - fb775b01-d8c1-429f-9bcf-f6072243ecfa)(label(e1))(mold((out \ + 8e94f35f-fc12-4ef8-9b04-07a56fc5fd9b)(label(v))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 71bfde98-6188-4e39-8718-53ab06960fd7)(label(,))(mold((out \ + 06a8b8a2-261c-4696-b967-3bc77eafc8b3)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 15))(sort \ + Exp))((shape(Concave 15))(sort \ + Exp))))))(shards(0))(children())))(Tile((id \ + 905c338c-14ca-4660-bf57-ad2505d50f57)(label(name))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 8fe769e6-8b88-4faf-ba0f-2fb447414e97)(label(,))(mold((out \ Exp)(in_())(nibs(((shape(Concave 15))(sort \ Exp))((shape(Concave 15))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 107a49d0-6226-4c20-b01d-2d186724b94a)(content(Whitespace\" \ + b72b3481-34de-48f9-a5e5-e68d829a24c4)(content(Whitespace\" \ \"))))(Tile((id \ - 83a585a9-cc40-4183-9910-b70254b15874)(label(e2))(mold((out \ + 35e4c324-e7ac-498f-837a-7a9d8d36a734)(label(body))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ - Exp))))))(shards(0))(children()))))))))(Secondary((id \ - d387e36c-ec5c-4782-9d1f-2739c7a7634b)(content(Whitespace\"\\n\"))))(Tile((id \ - af626056-2da3-4259-a568-1f8298527f08)(label(| =>))(mold((out \ + Exp))))))(shards(0))(children())))))))))))))(Secondary((id \ + d98eb89a-235e-4376-8349-0fd15b6fae02)(content(Whitespace\"\\n\"))))(Tile((id \ + 198d47d6-6294-43bc-b006-0d85eb8a2669)(label(| =>))(mold((out \ Rul)(in_(Pat))(nibs(((shape(Concave 21))(sort \ Exp))((shape(Concave 21))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - f58409e9-8883-4d5b-a2fb-238bdcd2f1a9)(content(Whitespace\" \ - \"))))(Tile((id \ - 19d627fa-ff3f-4bfd-9b0d-e081a5f093cd)(label(Ap))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - ecc7492a-35a5-48dd-b314-052701cebe01)(label(\"(\"\")\"))(mold((out \ - Pat)(in_(Pat))(nibs(((shape(Concave 2))(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ - 5634f8f7-a1cc-4d2f-a2d9-ee6dd302559e)(label(e1))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - 319722e0-1df1-4ff5-85de-637f59e5c6fb)(label(,))(mold((out \ - Pat)(in_())(nibs(((shape(Concave 15))(sort \ - Pat))((shape(Concave 15))(sort \ - Pat))))))(shards(0))(children())))(Secondary((id \ - 46f51f43-b3f1-4894-9c36-054921466663)(content(Whitespace\" \ - \"))))(Tile((id \ - c732f687-3289-4066-b86a-a2d013189e03)(label(e2))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children()))))))))(Tile((id \ - 366fdfb4-ed4b-44ac-9b49-f90cc6f46d8c)(label(,))(mold((out \ - Pat)(in_())(nibs(((shape(Concave 15))(sort \ - Pat))((shape(Concave 15))(sort \ - Pat))))))(shards(0))(children())))(Secondary((id \ - 836b7c9b-ed4b-4a8f-be0f-3ff6c4230d84)(content(Whitespace\" \ + bcc48b90-9af3-4c00-9e0c-ce72bb2b732f)(content(Whitespace\" \ \"))))(Tile((id \ - a876e608-fe27-4de6-9e60-ce7e6d046f36)(label(Ap))(mold((out \ + 6a1718f8-8022-40b3-ab93-d4211208c29c)(label(Ap))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - da2c7661-ffe8-4fdc-a9f0-0aecec3be262)(label(\"(\"\")\"))(mold((out \ + b922c7f6-c67c-48f3-8cfb-68c841aa0414)(label(\"(\"\")\"))(mold((out \ Pat)(in_(Pat))(nibs(((shape(Concave 2))(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ - 9ed91e1a-c75b-48a4-b5aa-c96dd5ad2e82)(label(e3))(mold((out \ + 07da188a-2410-44f9-b027-fa69828a2b60)(label(e1))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - d18abadc-274b-4d01-a47f-745585122bd5)(label(,))(mold((out \ + 8ef9466b-7fcc-4137-bfb4-692ccf70dbd4)(label(,))(mold((out \ Pat)(in_())(nibs(((shape(Concave 15))(sort \ Pat))((shape(Concave 15))(sort \ - Pat))))))(shards(0))(children())))(Secondary((id \ - b0a80da2-1d57-4710-8cab-e7df5dc3c53e)(content(Whitespace\" \ - \"))))(Tile((id \ - 013f27da-4aa0-4581-b824-3e4f008684ed)(label(e4))(mold((out \ + Pat))))))(shards(0))(children())))(Tile((id \ + f00bb251-cbab-46be-8173-1f6675ee4c12)(label(e2))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort \ Pat))))))(shards(0))(children()))))))))(Secondary((id \ - 3e11240a-71fc-4de0-ba1c-b5d07365de39)(content(Whitespace\" \ + e64b3ba2-1bb9-46f8-af06-493d15f723a6)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 2f614776-e35e-462f-b803-96f9be39c6cb)(content(Whitespace\"\\n\"))))(Secondary((id \ - 9a6e76ae-34e3-453c-b347-801f24f509dd)(content(Whitespace\" \ + 4e59e4ca-6f08-4448-9c58-9483c07efd66)(content(Whitespace\"\\n\"))))(Secondary((id \ + 8ee684cd-2c5a-4253-b301-7cba81099e24)(content(Whitespace\" \ \"))))(Secondary((id \ - 9488f1ca-eb41-49a0-a0f1-90e9f1864458)(content(Whitespace\" \ + 49bc3c61-c4d8-4dea-aca2-e338d6badf43)(content(Whitespace\" \ \"))))(Tile((id \ - 7750c1a4-f4cf-4976-a9d3-86c65c012652)(label(exp_equal))(mold((out \ + a52cd9fc-0c23-475b-9415-25f6fa9e6efb)(label(Ap))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - ba7b5f88-404a-42b1-a8c4-b654f3dc59e5)(label(\"(\"\")\"))(mold((out \ + 691eae01-24d8-4eef-8f2d-fd96f5655ce1)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 2))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 50c34596-30b6-4b5a-87db-27f96170b6a3)(label(e1))(mold((out \ + 2b9d4d26-68e0-4bcd-8180-4f5604325e72)(label(subst))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - c95da88e-6a74-48d8-9cf6-c605d5c3a701)(label(,))(mold((out \ + 61a618b7-9ee6-4e7f-a857-70e856565de6)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 2))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 33aed735-bcb4-4f72-90e7-0905627c1328)(label(v))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + a962694c-b142-42d8-b708-ece24fe1abd5)(label(,))(mold((out \ Exp)(in_())(nibs(((shape(Concave 15))(sort \ Exp))((shape(Concave 15))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 00c73886-9a6c-479a-9a0d-be062ea3910f)(content(Whitespace\" \ + 42355414-1a94-465d-b514-efafd3dde3ce)(content(Whitespace\" \ \"))))(Tile((id \ - 26d9bb64-0a0c-4be4-9464-4569661ccf02)(label(e3))(mold((out \ + 25868761-b6df-412e-ab62-429c9dd56013)(label(name))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort \ - Exp))))))(shards(0))(children()))))))))(Secondary((id \ - d1c5b415-ed05-498d-bce0-9de00a700394)(content(Whitespace\" \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 0c61b948-4a9b-4749-94f4-937e40189067)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 15))(sort \ + Exp))((shape(Concave 15))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 6f94e0f0-3a32-42d5-a969-04770fb2f6e9)(content(Whitespace\" \ \"))))(Tile((id \ - 08303392-a90c-4d31-814a-2a051d9667b0)(label(&&))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 10))(sort \ - Exp))((shape(Concave 10))(sort \ + 05ce26ab-13fe-4ca3-b44b-97e1fabbd9aa)(label(e1))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children()))))))))(Tile((id \ + e232b397-8a48-4905-9901-a6614c29b148)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 15))(sort \ + Exp))((shape(Concave 15))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - e7677fe6-48be-4899-9e0f-e1b29280e44a)(content(Whitespace\" \ + 7cad6a0a-f538-4103-8ea9-a25188ed9c5d)(content(Whitespace\" \ \"))))(Tile((id \ - 516eabb3-4a51-4c59-9940-c492b45f3efe)(label(exp_equal))(mold((out \ + c7974f67-be67-4b25-b4e2-792f6271485c)(label(subst))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - e68b5ecb-929f-4854-af5a-024f13d8be93)(label(\"(\"\")\"))(mold((out \ + 33a5c704-20a9-4923-83ee-bc25c55193de)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 2))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 83fa3d15-4b89-45be-965a-227e4fb29bc8)(label(e2))(mold((out \ + 13c5b7a5-2e40-4eb5-a453-69244de39c0f)(label(v))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 3d8e63e4-3075-4185-806e-303e0c85fbf7)(label(,))(mold((out \ + 421e99c0-8c79-4eaf-b157-a55567fc08f2)(label(,))(mold((out \ Exp)(in_())(nibs(((shape(Concave 15))(sort \ Exp))((shape(Concave 15))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 2337432a-0774-4754-b172-a957d6a5c46a)(content(Whitespace\" \ + f7a6368c-22ce-4e48-a850-f2b518249ba2)(content(Whitespace\" \ \"))))(Tile((id \ - 5d704e11-c851-4bee-bd41-fc97c530e003)(label(e4))(mold((out \ + b5d916c8-ff45-42d4-87e2-b368456a1b0a)(label(name))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort \ - Exp))))))(shards(0))(children()))))))))(Secondary((id \ - 7c28d9c0-a994-4ec0-a985-641ee916988f)(content(Whitespace\"\\n\"))))(Tile((id \ - 81be554c-d1ad-4215-874d-1f4b370c7ce5)(label(| =>))(mold((out \ - Rul)(in_(Pat))(nibs(((shape(Concave 21))(sort \ - Exp))((shape(Concave 21))(sort Exp))))))(shards(0 \ - 1))(children(((Secondary((id \ - 3f839aa4-9308-4b6b-a336-ddf2f5a35100)(content(Whitespace\" \ - \"))))(Tile((id \ - ef9d6fc5-5b9e-4877-bdc5-bcb5edd5e202)(label(_))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - 4734e14d-af00-46ba-8a2c-29a40730d6bd)(content(Whitespace\" \ - \")))))))))(Secondary((id \ - d7c88fc6-e58f-42f5-9e34-6d7994d3726f)(content(Whitespace\" \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 594de8b9-d5e3-4a8a-b6b4-a88747f4976c)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 15))(sort \ + Exp))((shape(Concave 15))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 4b4d1d9a-6ec5-482a-a2e8-294b620f10b2)(content(Whitespace\" \ \"))))(Tile((id \ - 710f92ac-46d8-4cbd-8289-d63621b6a898)(label(false))(mold((out \ + 8255fbeb-57bc-4623-a976-6a77d4f4bd33)(label(e2))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - d0c796b9-cf69-4f65-ba17-045f3f632ee3)(content(Whitespace\" \ - \")))))))))(Secondary((id \ - d2a47d78-3131-42d9-af47-7a0d98bebc8a)(content(Whitespace\" \ + Convex)(sort \ + Exp))))))(shards(0))(children())))))))))))))(Secondary((id \ + 46c0e133-7139-4de4-b049-ea74f738219d)(content(Whitespace\" \ \")))))))))(Secondary((id \ - b54c98e0-13ad-4880-9974-791df224ef2a)(content(Whitespace\"\\n\"))))(Secondary((id \ - 3da9af7c-a6d2-495f-80d8-adf3cadde53b)(content(Whitespace\"\\n\"))))(Secondary((id \ - 774b07c3-7264-4e6a-a5c9-d702263f7167)(content(Comment\"# \ - Substitute Exp v for variable name in Exp e \ - #\"))))(Secondary((id \ - 426539c8-aaf5-4b69-869e-f7bafc266eea)(content(Whitespace\"\\n\"))))(Tile((id \ + 1429043f-125e-47a0-a8fa-ea29e06ec217)(content(Whitespace\" \ + \")))))))(ancestors((((id \ 74de8fc5-e81b-4634-b34f-da0dbc8b0957)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 17))(sort Exp))))))(shards(0 1 \ - 2))(children(((Secondary((id \ + Exp))((shape(Concave 17))(sort Exp))))))(shards((0 \ + 1)(2)))(children((((Secondary((id \ 352d8989-84fd-4829-b6cb-5bde729ace4e)(content(Whitespace\" \ \"))))(Tile((id \ 6001c0ea-e744-4a22-aafb-7c59f5aecadf)(label(subst))(mold((out \ @@ -14611,283 +14665,443 @@ let startup : PersistentData.t = 297eefa1-4efd-450b-8aa2-f78566d739a2)(label(Exp))(mold((out \ Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ Convex)(sort \ - Typ))))))(shards(0))(children()))))((Secondary((id \ - ab4e863d-fe5e-4773-aee7-47ea69e9a81f)(content(Whitespace\"\\n\"))))(Tile((id \ - 219a6daf-2bc5-4d0b-acf0-9dfc2d57fff8)(label(fun \ - ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 14))(sort Exp))))))(shards(0 \ - 1))(children(((Secondary((id \ - a196a02c-46be-4da2-9762-5c375d09afe7)(content(Whitespace\" \ + Typ))))))(shards(0))(children())))))())))(((Secondary((id \ + 579a2658-f19d-496b-83bb-3840422b8218)(content(Comment\"# \ + Lambda Calculus via evaluation by substitution \ + #\"))))(Secondary((id \ + 58d3c269-21cb-4b04-839c-d1e745cd6c9a)(content(Whitespace\"\\n\"))))(Secondary((id \ + b3539b17-f970-4b91-a865-6f442db15e21)(content(Whitespace\"\\n\"))))(Secondary((id \ + 53f9307e-6888-4508-86de-8c15c2a0b734)(content(Comment\"# An \ + Expression is a variable, function, or application \ + #\"))))(Secondary((id \ + c9014d63-730a-4661-b521-6b44ae002db9)(content(Whitespace\"\\n\"))))(Tile((id \ + 3b6f8f45-d98f-453f-815a-57eaf3789cbd)(label(type = \ + in))(mold((out Exp)(in_(TPat Typ))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 17))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 904b8eb7-4c19-4abf-8637-740ad6c6186a)(content(Whitespace\" \ \"))))(Tile((id \ - 71fc3e6a-b851-4014-8194-81012a9e6602)(label(v))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - 4318d3e7-c631-4b2e-9a7a-0e5bc7898466)(label(,))(mold((out \ - Pat)(in_())(nibs(((shape(Concave 15))(sort \ - Pat))((shape(Concave 15))(sort \ - Pat))))))(shards(0))(children())))(Secondary((id \ - 1abe26ac-ac76-4d60-b72d-4c84b71df926)(content(Whitespace\" \ + 66b489b4-bfd2-406f-810e-f47537d21ae6)(label(Exp))(mold((out \ + TPat)(in_())(nibs(((shape Convex)(sort TPat))((shape \ + Convex)(sort \ + TPat))))))(shards(0))(children())))(Secondary((id \ + 6d84ad07-906b-4b91-9aa3-18e606c93cf1)(content(Whitespace\" \ + \")))))((Secondary((id \ + e23cac29-dd75-4613-93c9-77f014f56f31)(content(Whitespace\"\\n\"))))(Tile((id \ + 81ac84c9-29d1-463c-941e-57b267719ff3)(label(+))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape(Concave \ + 11))(sort Typ))))))(shards(0))(children())))(Secondary((id \ + b4a22f35-2ed9-430f-919e-b2ee80cee5bd)(content(Whitespace\" \ \"))))(Tile((id \ - dc4f1bd4-abc3-4d55-b0ef-3d06e7d3d2f6)(label(name))(mold((out \ + 8b41055c-70d6-45c2-940f-5c2d826e61db)(label(Var))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ + bb5c65e6-bd07-41b2-a344-a687b0f42718)(label(\"(\"\")\"))(mold((out \ + Typ)(in_(Typ))(nibs(((shape(Concave 2))(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0 1))(children(((Tile((id \ + 6eac0ae4-7b36-443a-88c7-509db5d45436)(label(String))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ + 354cfa7b-69f9-4d5a-83d6-0a2c199a74c3)(content(Whitespace\"\\n\"))))(Tile((id \ + 35331ee6-8a63-44da-9424-40ac844466c4)(label(+))(mold((out \ + Typ)(in_())(nibs(((shape(Concave 11))(sort \ + Typ))((shape(Concave 11))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + 65a261a6-148a-4d37-9ab6-93756a5bc85a)(content(Whitespace\" \ + \"))))(Tile((id \ + e25ed46e-a960-4707-bc68-c0b815371fc1)(label(Lam))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ + 36db6124-df59-471f-94fc-3a309d41252c)(label(\"(\"\")\"))(mold((out \ + Typ)(in_(Typ))(nibs(((shape(Concave 2))(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0 1))(children(((Tile((id \ + 93389af3-f3ed-495b-85cf-3982c385fa1e)(label(String))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ + f32f8b6d-872c-441c-b5f3-77d23dc887e8)(label(,))(mold((out \ + Typ)(in_())(nibs(((shape(Concave 15))(sort \ + Typ))((shape(Concave 15))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + 3f06cf74-6b7d-47c6-b07f-05c09466cc24)(content(Whitespace\" \ + \"))))(Tile((id \ + 82369742-b375-4963-99a3-f73ce9d30508)(label(Exp))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ + 5be3a31d-1b8e-401e-bde0-14ded0a7ff4c)(content(Whitespace\"\\n\"))))(Tile((id \ + 9246efbe-34a1-41f7-92bf-41568937b53a)(label(+))(mold((out \ + Typ)(in_())(nibs(((shape(Concave 11))(sort \ + Typ))((shape(Concave 11))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + 68ef1881-fac3-41c7-99ef-a9243d67551f)(content(Whitespace\" \ + \"))))(Tile((id \ + e8e6e9f3-3788-4813-a8ec-850f7cbe3241)(label(Ap))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ + 2680b9e1-85d9-4910-bfb2-176f29dfa383)(label(\"(\"\")\"))(mold((out \ + Typ)(in_(Typ))(nibs(((shape(Concave 2))(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0 1))(children(((Tile((id \ + 73ed87ff-dd1a-4f71-aa3a-5dd42e15b926)(label(Exp))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ + 442dcc5c-8386-4ec1-bc9f-2685b18ab7d0)(label(,))(mold((out \ + Typ)(in_())(nibs(((shape(Concave 15))(sort \ + Typ))((shape(Concave 15))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + acf2010e-395f-40c6-a340-59ef389a3e49)(content(Whitespace\" \ + \"))))(Tile((id \ + 7e9227bd-8441-4fa9-9c16-024a91a9e513)(label(Exp))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ + 39e00c73-a5a2-4249-a0ae-df55a1f0f6b4)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + c2faba41-d1f2-4720-8245-64f06fc2ce13)(content(Whitespace\"\\n\"))))(Secondary((id \ + 4baf2caa-6b6d-4546-b6a2-0cfa47a86289)(content(Whitespace\"\\n\"))))(Secondary((id \ + 18808867-1152-40f9-ad32-2c142d01d247)(content(Comment\"# \ + Syntatic Equality of Expressions #\"))))(Secondary((id \ + 7b04a7ea-2e9a-45bc-bd28-01ca94ab1ce5)(content(Whitespace\"\\n\"))))(Tile((id \ + 9af020ec-3e6a-42b5-ae4a-4416f5b8141a)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 17))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 891fac75-70a7-47a2-ae6c-f264a06875c1)(content(Whitespace\" \ + \"))))(Tile((id \ + e4ca9d4f-8942-4826-9fd7-757ca711a3e2)(label(exp_equal))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - a1ec902c-e5b7-42e9-b76a-e0f1c1ce1dd4)(label(,))(mold((out \ - Pat)(in_())(nibs(((shape(Concave 15))(sort \ - Pat))((shape(Concave 15))(sort \ - Pat))))))(shards(0))(children())))(Secondary((id \ - f39b26a7-18fa-4d6d-bc10-5a86815b580f)(content(Whitespace\" \ + 3505d0bf-0ff7-4e6e-8e69-bb2a191cf4d4)(label(:))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 12))(sort \ + Pat))((shape(Concave 12))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + a497eb20-cf3f-4ef7-b165-45a9e855923a)(content(Whitespace\" \ \"))))(Tile((id \ - d0e16c86-d3ec-4e39-98e6-51ab274d8cd1)(label(e))(mold((out \ + afe12787-4b57-49c8-baed-316afa71c5fc)(label(\"(\"\")\"))(mold((out \ + Typ)(in_(Typ))(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0 1))(children(((Tile((id \ + 192cce66-f0d9-4434-b6d1-7aa733083586)(label(Exp))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Tile((id \ + 8063def0-fde4-4cab-a9c7-fc7b3f962da9)(label(,))(mold((out \ + Typ)(in_())(nibs(((shape(Concave 15))(sort \ + Typ))((shape(Concave 15))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + 7db42639-afc1-4b83-9b03-639d9edb28b3)(content(Whitespace\" \ + \"))))(Tile((id \ + b2dc55fa-30a5-4cc6-84f7-4c46ad679c4e)(label(Exp))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort \ + Typ))))))(shards(0))(children()))))))))(Secondary((id \ + d0a96d6b-dff9-48dd-b423-a5968f7e4aed)(content(Whitespace\" \ + \"))))(Tile((id \ + c1175695-ebd5-427d-92d3-fb22474cc58c)(label(->))(mold((out \ + Typ)(in_())(nibs(((shape(Concave 6))(sort \ + Typ))((shape(Concave 6))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + 770f873e-d093-4861-bee2-11d454695ca5)(content(Whitespace\" \ + \"))))(Tile((id \ + ad33920a-601a-4246-9426-7eb90bd7571f)(label(Bool))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + 05298787-a73a-43ab-8ffc-1046f3fc8b05)(content(Whitespace\" \ + \")))))((Secondary((id \ + 184629c3-7fad-4f2b-9c53-a74ca7a3d63d)(content(Whitespace\"\\n\"))))(Tile((id \ + 98082679-8cc9-4d38-abe5-4ac6e4cea1cd)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 14))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 9ec23bc0-f548-42a0-b241-aa75d9fa6527)(content(Whitespace\" \ + \"))))(Tile((id \ + 689fed0b-30e9-4ca4-8fe6-fda72c60e103)(label(es))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - e8c29ad7-e1eb-488f-9aab-cb88d6a08484)(content(Whitespace\" \ + 793d6fcd-45b8-4d78-a38e-d3fd69ca38a7)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 3de61dc3-139e-4ce5-b9c4-92c7d6a7a218)(content(Whitespace\"\\n\"))))(Tile((id \ - 9b89f0ba-7886-4803-aa11-c1a693afc3a4)(label(case \ + 3ac5410d-2711-4db4-9ed1-d65e01c6903b)(content(Whitespace\"\\n\"))))(Tile((id \ + 180d0645-b358-424c-b871-1289619589bc)(label(case \ end))(mold((out Exp)(in_(Rul))(nibs(((shape Convex)(sort \ Exp))((shape Convex)(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - 7becd8a7-6c1c-4f2f-9c6a-2637e7284820)(content(Whitespace\" \ + 75d98680-2cfe-4d2c-8005-6f770a2c4a58)(content(Whitespace\" \ \"))))(Tile((id \ - 58e8f274-fa5c-4a08-a050-7840beca26df)(label(e))(mold((out \ + 4d98706e-25e6-4404-bd81-b4c19b19db2d)(label(es))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - c917b2fc-b1f6-4494-bae7-fdc5d8314ac0)(content(Whitespace\"\\n\"))))(Tile((id \ - ffee5d55-f2d7-4b66-91ca-e199c1eedd44)(label(| =>))(mold((out \ + cb5d85d8-6c5f-4d35-acf9-2716f96c11fa)(content(Whitespace\"\\n\"))))(Tile((id \ + f018da47-6f03-4d21-9a18-320122d8ce0d)(label(| =>))(mold((out \ Rul)(in_(Pat))(nibs(((shape(Concave 21))(sort \ Exp))((shape(Concave 21))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - fa4628a7-b6e2-40a9-912d-9ab2003e66ab)(content(Whitespace\" \ + 6c565fa4-0199-4227-aad8-50f82c08dad5)(content(Whitespace\" \ \"))))(Tile((id \ - 4f300848-04c1-4d28-a9ac-34cb3d72005c)(label(Var))(mold((out \ + d6605b32-8436-481e-a4ab-66074fd68305)(label(Var))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - 5d3a134c-3f74-4fdc-818c-037d3ee533b0)(label(\"(\"\")\"))(mold((out \ + dee86624-d32e-4e70-8edd-d4e7d58d37f7)(label(\"(\"\")\"))(mold((out \ Pat)(in_(Pat))(nibs(((shape(Concave 2))(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ - ff0ccc42-3ffd-4432-a1d6-a070e2b6f346)(label(n))(mold((out \ + 13b4fe0e-bcaa-4283-8f3f-a0e13dcd40bb)(label(x))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children()))))))))(Tile((id \ + 493926e4-6cbb-44cc-b206-ead1cec82092)(label(,))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 15))(sort \ + Pat))((shape(Concave 15))(sort \ + Pat))))))(shards(0))(children())))(Secondary((id \ + 05377add-3eba-48f8-ada1-26eb74fbc3c0)(content(Whitespace\" \ + \"))))(Tile((id \ + 7945262f-0e83-4a65-a946-bdab7b39424f)(label(Var))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ + 8de1adaa-fa8e-48ce-89ac-d903791c65a7)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape(Concave 2))(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ + 322e956e-a064-4731-8ba3-7b5ded46b0b0)(label(y))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort \ Pat))))))(shards(0))(children()))))))))(Secondary((id \ - 1561ab66-303f-4871-9b48-1bcc763a671e)(content(Whitespace\" \ + 9707713c-a669-437d-9447-58713fb6b8c5)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 8b9692ba-3782-4f79-a2e9-2ab485357d4d)(content(Whitespace\"\\n\"))))(Secondary((id \ - 96b3ae46-b8c8-432e-8dce-07b229df5a88)(content(Whitespace\" \ - \"))))(Secondary((id \ - 2f4a7d91-7dc4-4da6-8371-318822592b07)(content(Whitespace\" \ - \"))))(Tile((id \ - 1aedd057-2c2b-455a-a1a2-b5f1e41909e0)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 7738b2b4-d591-4ade-b3b6-f05b1907e6d8)(label(if then \ - else))(mold((out Exp)(in_(Exp Exp))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 13))(sort Exp))))))(shards(0 1 \ - 2))(children(((Secondary((id \ - b3306766-434f-425e-bf19-10aeaeec9b99)(content(Whitespace\" \ + 482ff6f8-2d76-455d-9a94-a1c09b073eac)(content(Whitespace\" \ \"))))(Tile((id \ - e7d7a06c-4c8d-4852-b69c-2c5a2836c7fb)(label(n))(mold((out \ + ab0ffd4a-8d3a-47d8-9149-2d2b96c45204)(label(x))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 712dad6c-a685-4294-88a3-b79fc2e7950f)(label($==))(mold((out \ + 309d2d36-e859-448d-a80c-cea3bc9d3454)(label($==))(mold((out \ Exp)(in_())(nibs(((shape(Concave 9))(sort \ Exp))((shape(Concave 9))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 87e9ee65-9c06-42ec-acd2-b93b3f777c2f)(content(Whitespace\" \ - \"))))(Tile((id \ - f9e3a6fb-5b11-49c7-b219-741d1ccbd526)(label(name))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - 2dc75d3c-7a4f-4b64-9e43-01ac29e2717b)(content(Whitespace\" \ - \")))))((Secondary((id \ - 4683c684-877a-4546-a637-a5a8a03a6822)(content(Whitespace\" \ + 13d30f0b-ebdb-4498-b392-8aa47b849281)(content(Whitespace\" \ \"))))(Tile((id \ - 189fae6c-2558-4681-a09a-1e13f70bb17e)(label(v))(mold((out \ + 32f78d11-4e5c-4bb8-b663-75936231f228)(label(y))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - 67ff8509-6b9f-4707-b3a0-63f33fde3378)(content(Whitespace\" \ - \")))))))))(Secondary((id \ - 3d008a86-4add-45b4-ae61-6d0c47eb43ad)(content(Whitespace\" \ - \"))))(Tile((id \ - 1fd0007d-1e2e-4149-bf0b-e91bb130fef1)(label(e))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort \ - Exp))))))(shards(0))(children()))))))))(Secondary((id \ - ad4f733a-2033-4e4a-992b-25cd79c81ec2)(content(Whitespace\"\\n\"))))(Tile((id \ - 50e8ef28-d17c-4c54-b0a8-20182938f045)(label(| =>))(mold((out \ + a6b02ca9-65a3-423c-8a2d-98b69271daa7)(content(Whitespace\"\\n\"))))(Tile((id \ + 315a9b91-39f1-4001-9c52-3ee45f73989f)(label(| =>))(mold((out \ Rul)(in_(Pat))(nibs(((shape(Concave 21))(sort \ Exp))((shape(Concave 21))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - 512cb880-2a52-4828-aa7f-c3a497144c27)(content(Whitespace\" \ + a6917a08-5b7c-4519-a67d-4ea8a31932a6)(content(Whitespace\" \ \"))))(Tile((id \ - fe07cd73-0165-4a4e-963d-10c0851148d6)(label(Lam))(mold((out \ + 58e1ac3f-e659-4372-9510-386d7ebe50f7)(label(Lam))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - 583cd22d-feb9-4699-9d2d-a299de446af4)(label(\"(\"\")\"))(mold((out \ + 073c5366-7d94-470f-adb5-f383a9eaa4bb)(label(\"(\"\")\"))(mold((out \ Pat)(in_(Pat))(nibs(((shape(Concave 2))(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ - 0a213226-4739-4717-b595-5a767c2ac08b)(label(x))(mold((out \ + 9b281aa5-8d06-4714-9cd2-ffab5b0c71ea)(label(x1))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - d986e7be-4ba6-4517-ba63-4353fc7a6590)(label(,))(mold((out \ + c618ba26-4a6e-4726-bad5-90f9983e6fe5)(label(,))(mold((out \ Pat)(in_())(nibs(((shape(Concave 15))(sort \ Pat))((shape(Concave 15))(sort \ Pat))))))(shards(0))(children())))(Secondary((id \ - 39255e0e-1274-4798-a161-93c16f0c4f6c)(content(Whitespace\" \ + 29339c3b-fb4e-41f4-8cd4-cad7426fa6c1)(content(Whitespace\" \ \"))))(Tile((id \ - 9898ec8e-d5bd-4c3f-b3d5-0f068e906326)(label(body))(mold((out \ + fc86dc77-9c0b-4a37-987a-6b9f83dfcd7f)(label(e1))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children()))))))))(Tile((id \ + be7a697f-0d3f-498c-b036-bed60ec00fdd)(label(,))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 15))(sort \ + Pat))((shape(Concave 15))(sort \ + Pat))))))(shards(0))(children())))(Secondary((id \ + c4083882-1dae-4651-ab52-c9b1c4e7ced1)(content(Whitespace\" \ + \"))))(Tile((id \ + 42b509d9-0759-480f-857c-3d82df96e158)(label(Lam))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ + 02429a5b-fff7-4b42-a5be-9acd44a729fb)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape(Concave 2))(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ + c76367a5-6ef8-41f5-9599-faf285ff1878)(label(x2))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ + b7b861e4-22d0-437f-bd2c-95d57d7370fc)(label(,))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 15))(sort \ + Pat))((shape(Concave 15))(sort \ + Pat))))))(shards(0))(children())))(Secondary((id \ + b7609391-f2ce-4d1e-bbe6-3a25fa099458)(content(Whitespace\" \ + \"))))(Tile((id \ + f3d69f1d-8f6b-4095-a97e-d6e61d97b4b7)(label(e2))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort \ Pat))))))(shards(0))(children()))))))))(Secondary((id \ - 6a4ad6e7-d48b-4866-9ace-cbde29edc492)(content(Whitespace\" \ + 0e5305cd-0907-4947-87e9-37da9fcc349d)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 1b1fd754-1200-4a0a-8df2-27b97617942e)(content(Whitespace\"\\n\"))))(Secondary((id \ - 37fcc3ae-97a7-42f8-b795-90b5305cc46f)(content(Whitespace\" \ + 143d94d0-7ea4-4f2d-b70e-e23baf9cd31a)(content(Whitespace\"\\n\"))))(Secondary((id \ + d264c081-8f4b-4254-b6a9-de34f5286a6c)(content(Whitespace\" \ \"))))(Secondary((id \ - 898a6aea-5011-41cb-bda5-c4844285deec)(content(Whitespace\" \ + c9d7e936-7bc6-4e4e-b0c2-ce0e25fa93e7)(content(Whitespace\" \ \"))))(Tile((id \ - 4321f0b3-5146-4f8c-9015-3bffaac6537f)(label(Lam))(mold((out \ + 34583060-75ce-4137-802e-b2a55ff9645e)(label(x1))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - c6f6c21b-6ea5-4ef7-bd60-97755a20b4df)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape(Concave 2))(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 413bd5cb-afce-4a31-bfec-c4c80e708bcb)(label(x))(mold((out \ + 8f95d04f-b61b-4abb-8b77-3d8e0d535d88)(label($==))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 9))(sort \ + Exp))((shape(Concave 9))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 0938c068-c702-468e-b785-cf7004de3ca2)(content(Whitespace\" \ + \"))))(Tile((id \ + f7399b45-070e-47bc-949f-88f0ea9efc49)(label(x2))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 50cb1442-335b-4cd1-b2e4-867579fdaba6)(label(,))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 15))(sort \ - Exp))((shape(Concave 15))(sort \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 62f423d3-1612-47e6-923e-bbae907e2a35)(content(Whitespace\" \ + \"))))(Tile((id \ + 63b9d6fd-d888-47b4-8364-49366bc74d65)(label(&&))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 10))(sort \ + Exp))((shape(Concave 10))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 2fe3d96e-0c7c-4011-a604-630ca52de2e6)(content(Whitespace\" \ + cc2ac2c0-43d5-4ce5-a451-18c097e284c4)(content(Whitespace\" \ \"))))(Tile((id \ - 825ea4de-9981-4dfb-969f-5901d16c14f1)(label(subst))(mold((out \ + 787f8c3c-346c-4f69-a3d8-14f0ea05d731)(label(exp_equal))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 06e5576f-8c2a-494c-84f0-e6c44b6fc289)(label(\"(\"\")\"))(mold((out \ + 70ed7427-b523-4292-9805-08aaca91925a)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 2))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 8e94f35f-fc12-4ef8-9b04-07a56fc5fd9b)(label(v))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 06a8b8a2-261c-4696-b967-3bc77eafc8b3)(label(,))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 15))(sort \ - Exp))((shape(Concave 15))(sort \ - Exp))))))(shards(0))(children())))(Tile((id \ - 905c338c-14ca-4660-bf57-ad2505d50f57)(label(name))(mold((out \ + fb775b01-d8c1-429f-9bcf-f6072243ecfa)(label(e1))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 8fe769e6-8b88-4faf-ba0f-2fb447414e97)(label(,))(mold((out \ + 71bfde98-6188-4e39-8718-53ab06960fd7)(label(,))(mold((out \ Exp)(in_())(nibs(((shape(Concave 15))(sort \ Exp))((shape(Concave 15))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - b72b3481-34de-48f9-a5e5-e68d829a24c4)(content(Whitespace\" \ + 107a49d0-6226-4c20-b01d-2d186724b94a)(content(Whitespace\" \ \"))))(Tile((id \ - 35e4c324-e7ac-498f-837a-7a9d8d36a734)(label(body))(mold((out \ + 83a585a9-cc40-4183-9910-b70254b15874)(label(e2))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ - Exp))))))(shards(0))(children())))))))))))))(Secondary((id \ - d98eb89a-235e-4376-8349-0fd15b6fae02)(content(Whitespace\"\\n\"))))(Tile((id \ - 198d47d6-6294-43bc-b006-0d85eb8a2669)(label(| =>))(mold((out \ + Exp))))))(shards(0))(children()))))))))(Secondary((id \ + d387e36c-ec5c-4782-9d1f-2739c7a7634b)(content(Whitespace\"\\n\"))))(Tile((id \ + af626056-2da3-4259-a568-1f8298527f08)(label(| =>))(mold((out \ Rul)(in_(Pat))(nibs(((shape(Concave 21))(sort \ Exp))((shape(Concave 21))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - bcc48b90-9af3-4c00-9e0c-ce72bb2b732f)(content(Whitespace\" \ + f58409e9-8883-4d5b-a2fb-238bdcd2f1a9)(content(Whitespace\" \ \"))))(Tile((id \ - 6a1718f8-8022-40b3-ab93-d4211208c29c)(label(Ap))(mold((out \ + 19d627fa-ff3f-4bfd-9b0d-e081a5f093cd)(label(Ap))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - b922c7f6-c67c-48f3-8cfb-68c841aa0414)(label(\"(\"\")\"))(mold((out \ + ecc7492a-35a5-48dd-b314-052701cebe01)(label(\"(\"\")\"))(mold((out \ Pat)(in_(Pat))(nibs(((shape(Concave 2))(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ - 07da188a-2410-44f9-b027-fa69828a2b60)(label(e1))(mold((out \ + 5634f8f7-a1cc-4d2f-a2d9-ee6dd302559e)(label(e1))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ - 8ef9466b-7fcc-4137-bfb4-692ccf70dbd4)(label(,))(mold((out \ + 319722e0-1df1-4ff5-85de-637f59e5c6fb)(label(,))(mold((out \ Pat)(in_())(nibs(((shape(Concave 15))(sort \ Pat))((shape(Concave 15))(sort \ - Pat))))))(shards(0))(children())))(Tile((id \ - f00bb251-cbab-46be-8173-1f6675ee4c12)(label(e2))(mold((out \ + Pat))))))(shards(0))(children())))(Secondary((id \ + 46f51f43-b3f1-4894-9c36-054921466663)(content(Whitespace\" \ + \"))))(Tile((id \ + c732f687-3289-4066-b86a-a2d013189e03)(label(e2))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children()))))))))(Tile((id \ + 366fdfb4-ed4b-44ac-9b49-f90cc6f46d8c)(label(,))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 15))(sort \ + Pat))((shape(Concave 15))(sort \ + Pat))))))(shards(0))(children())))(Secondary((id \ + 836b7c9b-ed4b-4a8f-be0f-3ff6c4230d84)(content(Whitespace\" \ + \"))))(Tile((id \ + a876e608-fe27-4de6-9e60-ce7e6d046f36)(label(Ap))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ + da2c7661-ffe8-4fdc-a9f0-0aecec3be262)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape(Concave 2))(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ + 9ed91e1a-c75b-48a4-b5aa-c96dd5ad2e82)(label(e3))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ + d18abadc-274b-4d01-a47f-745585122bd5)(label(,))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 15))(sort \ + Pat))((shape(Concave 15))(sort \ + Pat))))))(shards(0))(children())))(Secondary((id \ + b0a80da2-1d57-4710-8cab-e7df5dc3c53e)(content(Whitespace\" \ + \"))))(Tile((id \ + 013f27da-4aa0-4581-b824-3e4f008684ed)(label(e4))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort \ Pat))))))(shards(0))(children()))))))))(Secondary((id \ - e64b3ba2-1bb9-46f8-af06-493d15f723a6)(content(Whitespace\" \ + 3e11240a-71fc-4de0-ba1c-b5d07365de39)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 4e59e4ca-6f08-4448-9c58-9483c07efd66)(content(Whitespace\"\\n\"))))(Secondary((id \ - 8ee684cd-2c5a-4253-b301-7cba81099e24)(content(Whitespace\" \ + 2f614776-e35e-462f-b803-96f9be39c6cb)(content(Whitespace\"\\n\"))))(Secondary((id \ + 9a6e76ae-34e3-453c-b347-801f24f509dd)(content(Whitespace\" \ \"))))(Secondary((id \ - 49bc3c61-c4d8-4dea-aca2-e338d6badf43)(content(Whitespace\" \ + 9488f1ca-eb41-49a0-a0f1-90e9f1864458)(content(Whitespace\" \ \"))))(Tile((id \ - a52cd9fc-0c23-475b-9415-25f6fa9e6efb)(label(Ap))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 691eae01-24d8-4eef-8f2d-fd96f5655ce1)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape(Concave 2))(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 2b9d4d26-68e0-4bcd-8180-4f5604325e72)(label(subst))(mold((out \ + 7750c1a4-f4cf-4976-a9d3-86c65c012652)(label(exp_equal))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 61a618b7-9ee6-4e7f-a857-70e856565de6)(label(\"(\"\")\"))(mold((out \ + ba7b5f88-404a-42b1-a8c4-b654f3dc59e5)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 2))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 33aed735-bcb4-4f72-90e7-0905627c1328)(label(v))(mold((out \ + 50c34596-30b6-4b5a-87db-27f96170b6a3)(label(e1))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - a962694c-b142-42d8-b708-ece24fe1abd5)(label(,))(mold((out \ + c95da88e-6a74-48d8-9cf6-c605d5c3a701)(label(,))(mold((out \ Exp)(in_())(nibs(((shape(Concave 15))(sort \ Exp))((shape(Concave 15))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 42355414-1a94-465d-b514-efafd3dde3ce)(content(Whitespace\" \ + 00c73886-9a6c-479a-9a0d-be062ea3910f)(content(Whitespace\" \ \"))))(Tile((id \ - 25868761-b6df-412e-ab62-429c9dd56013)(label(name))(mold((out \ + 26d9bb64-0a0c-4be4-9464-4569661ccf02)(label(e3))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 0c61b948-4a9b-4749-94f4-937e40189067)(label(,))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 15))(sort \ - Exp))((shape(Concave 15))(sort \ - Exp))))))(shards(0))(children())))(Secondary((id \ - 6f94e0f0-3a32-42d5-a969-04770fb2f6e9)(content(Whitespace\" \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))(Secondary((id \ + d1c5b415-ed05-498d-bce0-9de00a700394)(content(Whitespace\" \ \"))))(Tile((id \ - 05ce26ab-13fe-4ca3-b44b-97e1fabbd9aa)(label(e1))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children()))))))))(Tile((id \ - e232b397-8a48-4905-9901-a6614c29b148)(label(,))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 15))(sort \ - Exp))((shape(Concave 15))(sort \ + 08303392-a90c-4d31-814a-2a051d9667b0)(label(&&))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 10))(sort \ + Exp))((shape(Concave 10))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 7cad6a0a-f538-4103-8ea9-a25188ed9c5d)(content(Whitespace\" \ + e7677fe6-48be-4899-9e0f-e1b29280e44a)(content(Whitespace\" \ \"))))(Tile((id \ - c7974f67-be67-4b25-b4e2-792f6271485c)(label(subst))(mold((out \ + 516eabb3-4a51-4c59-9940-c492b45f3efe)(label(exp_equal))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 33a5c704-20a9-4923-83ee-bc25c55193de)(label(\"(\"\")\"))(mold((out \ + e68b5ecb-929f-4854-af5a-024f13d8be93)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 2))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 13c5b7a5-2e40-4eb5-a453-69244de39c0f)(label(v))(mold((out \ + 83fa3d15-4b89-45be-965a-227e4fb29bc8)(label(e2))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 421e99c0-8c79-4eaf-b157-a55567fc08f2)(label(,))(mold((out \ + 3d8e63e4-3075-4185-806e-303e0c85fbf7)(label(,))(mold((out \ Exp)(in_())(nibs(((shape(Concave 15))(sort \ Exp))((shape(Concave 15))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - f7a6368c-22ce-4e48-a850-f2b518249ba2)(content(Whitespace\" \ + 2337432a-0774-4754-b172-a957d6a5c46a)(content(Whitespace\" \ \"))))(Tile((id \ - b5d916c8-ff45-42d4-87e2-b368456a1b0a)(label(name))(mold((out \ + 5d704e11-c851-4bee-bd41-fc97c530e003)(label(e4))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 594de8b9-d5e3-4a8a-b6b4-a88747f4976c)(label(,))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 15))(sort \ - Exp))((shape(Concave 15))(sort \ - Exp))))))(shards(0))(children())))(Secondary((id \ - 4b4d1d9a-6ec5-482a-a2e8-294b620f10b2)(content(Whitespace\" \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))(Secondary((id \ + 7c28d9c0-a994-4ec0-a985-641ee916988f)(content(Whitespace\"\\n\"))))(Tile((id \ + 81be554c-d1ad-4215-874d-1f4b370c7ce5)(label(| =>))(mold((out \ + Rul)(in_(Pat))(nibs(((shape(Concave 21))(sort \ + Exp))((shape(Concave 21))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 3f839aa4-9308-4b6b-a336-ddf2f5a35100)(content(Whitespace\" \ \"))))(Tile((id \ - 8255fbeb-57bc-4623-a976-6a77d4f4bd33)(label(e2))(mold((out \ + ef9d6fc5-5b9e-4877-bdc5-bcb5edd5e202)(label(_))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 4734e14d-af00-46ba-8a2c-29a40730d6bd)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + d7c88fc6-e58f-42f5-9e34-6d7994d3726f)(content(Whitespace\" \ + \"))))(Tile((id \ + 710f92ac-46d8-4cbd-8289-d63621b6a898)(label(false))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort \ - Exp))))))(shards(0))(children())))))))))))))(Secondary((id \ - 46c0e133-7139-4de4-b049-ea74f738219d)(content(Whitespace\" \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + d0c796b9-cf69-4f65-ba17-045f3f632ee3)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 1429043f-125e-47a0-a8fa-ea29e06ec217)(content(Whitespace\" \ + d2a47d78-3131-42d9-af47-7a0d98bebc8a)(content(Whitespace\" \ \")))))))))(Secondary((id \ + b54c98e0-13ad-4880-9974-791df224ef2a)(content(Whitespace\"\\n\"))))(Secondary((id \ + 3da9af7c-a6d2-495f-80d8-adf3cadde53b)(content(Whitespace\"\\n\"))))(Secondary((id \ + 774b07c3-7264-4e6a-a5c9-d702263f7167)(content(Comment\"# \ + Substitute Exp v for variable name in Exp e \ + #\"))))(Secondary((id \ + 426539c8-aaf5-4b69-869e-f7bafc266eea)(content(Whitespace\"\\n\")))))((Secondary((id \ 8d62629f-f58f-48a2-b11e-ab9a5b0d075a)(content(Whitespace\"\\n\"))))(Secondary((id \ 5a13baae-0472-42c0-b42a-b18bdc028226)(content(Whitespace\"\\n\"))))(Secondary((id \ df60bd6e-a698-4e36-b3df-c41a52d2f078)(content(Comment\"# \ @@ -15845,7 +16059,7 @@ let startup : PersistentData.t = Convex)(sort \ Exp))))))(shards(0))(children())))))))))))))))))))))))(Secondary((id \ ec814595-1e64-49d1-afcf-91e3ff70e2c2)(content(Whitespace\" \ - \"))))))))))))(ancestors())))(caret Outer))"; + \"))))))))))))))))(caret Outer))"; backup_text = "# Lambda Calculus via evaluation by substitution #\n\n\ # An Expression is a variable, function, or application #\n\ From 01a1d54a436823225c89ae81338ab9863ad42516 Mon Sep 17 00:00:00 2001 From: Matt Keenan Date: Fri, 13 Dec 2024 09:25:00 -0500 Subject: [PATCH 108/281] Fix failing test --- test/Test_Evaluator.re | 64 ++++++++++++++++++------------------------ 1 file changed, 28 insertions(+), 36 deletions(-) diff --git a/test/Test_Evaluator.re b/test/Test_Evaluator.re index 37fcaba764..ca85062226 100644 --- a/test/Test_Evaluator.re +++ b/test/Test_Evaluator.re @@ -56,53 +56,45 @@ let tet_ap_of_hole_deferral = () => Ap( Forward, Cast( - Cast( - EmptyHole |> Exp.fresh, - Unknown(Internal) |> Typ.fresh, - Arrow( - Unknown(Internal) |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) - |> Typ.fresh, - ) - |> Exp.fresh, + EmptyHole |> Exp.fresh, + Unknown(Internal) |> Typ.fresh, Arrow( Unknown(Internal) |> Typ.fresh, Unknown(Internal) |> Typ.fresh, ) |> Typ.fresh, - Arrow( - Prod([ + ) + |> Exp.fresh, + Cast( + Tuple([ + Cast( + Float(1.) |> Exp.fresh, + Float |> Typ.fresh, Unknown(Internal) |> Typ.fresh, + ) + |> Exp.fresh, + Cast( + Bool(true) |> Exp.fresh, + Bool |> Typ.fresh, Unknown(Internal) |> Typ.fresh, + ) + |> Exp.fresh, + Cast( + Int(3) |> Exp.fresh, + Int |> Typ.fresh, Unknown(Internal) |> Typ.fresh, - ]) - |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) - |> Typ.fresh, - ) - |> Exp.fresh, - Tuple([ - Cast( - Float(1.) |> Exp.fresh, - Float |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) + ) + |> Exp.fresh, + ]) |> Exp.fresh, - Cast( - Bool(true) |> Exp.fresh, - Bool |> Typ.fresh, + Prod([ Unknown(Internal) |> Typ.fresh, - ) - |> Exp.fresh, - Cast( - Int(3) |> Exp.fresh, - Int |> Typ.fresh, Unknown(Internal) |> Typ.fresh, - ) - |> Exp.fresh, - ]) + Unknown(Internal) |> Typ.fresh, + ]) + |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) |> Exp.fresh, ) |> Exp.fresh, From 8b65107c5c3476c9e7461ea69a8138b446de0318 Mon Sep 17 00:00:00 2001 From: Matt Keenan Date: Mon, 2 Dec 2024 15:17:33 -0500 Subject: [PATCH 109/281] remove req-value --- src/haz3lcore/dynamics/Builtins.re | 19 +-- src/haz3lcore/dynamics/Evaluator.re | 94 ++++---------- src/haz3lcore/dynamics/EvaluatorStep.re | 38 ------ src/haz3lcore/dynamics/Transition.re | 155 ++++++++---------------- src/haz3lcore/dynamics/Unboxing.re | 46 ++++++- src/haz3lcore/dynamics/ValueChecker.re | 59 +++------ 6 files changed, 141 insertions(+), 270 deletions(-) diff --git a/src/haz3lcore/dynamics/Builtins.re b/src/haz3lcore/dynamics/Builtins.re index 96b936e3f8..d68d6fd834 100644 --- a/src/haz3lcore/dynamics/Builtins.re +++ b/src/haz3lcore/dynamics/Builtins.re @@ -1,3 +1,4 @@ +open Util; open DHExp; /* @@ -12,13 +13,13 @@ open DHExp; [@deriving (show({with_path: false}), sexp)] type builtin = | Const(Typ.t, DHExp.t) - | Fn(Typ.t, Typ.t, DHExp.t => DHExp.t); + | Fn(Typ.t, Typ.t, DHExp.t => option(DHExp.t)); [@deriving (show({with_path: false}), sexp)] type t = VarMap.t_(builtin); [@deriving (show({with_path: false}), sexp)] -type forms = VarMap.t_(DHExp.t => DHExp.t); +type forms = VarMap.t_(DHExp.t => option(DHExp.t)); type result = Result.t(DHExp.t, EvaluatorError.t); @@ -29,7 +30,7 @@ let fn = name: Var.t, t1: Typ.term, t2: Typ.term, - impl: DHExp.t => DHExp.t, + impl: DHExp.t => option(DHExp.t), // None if indet builtins: t, ) : t => @@ -51,8 +52,8 @@ module Pervasives = { let unary = (f: DHExp.t => result, d: DHExp.t) => { switch (f(d)) { - | Ok(r') => r' - | Error(e) => EvaluatorError.Exception(e) |> raise + | Ok(r') => Some(r') + | Error(_) => None }; }; @@ -60,8 +61,8 @@ module Pervasives = { switch (term_of(d)) { | Tuple([d1, d2]) => switch (f(d1, d2)) { - | Ok(r) => r - | Error(e) => EvaluatorError.Exception(e) |> raise + | Ok(r) => Some(r) + | Error(_) => None } | _ => raise(EvaluatorError.Exception(InvalidBoxedTuple(d))) }; @@ -71,8 +72,8 @@ module Pervasives = { switch (term_of(d)) { | Tuple([d1, d2, d3]) => switch (f(d1, d2, d3)) { - | Ok(r) => r - | Error(e) => EvaluatorError.Exception(e) |> raise + | Ok(r) => Some(r) + | Error(_) => None } | _ => raise(EvaluatorError.Exception(InvalidBoxedTuple(d))) }; diff --git a/src/haz3lcore/dynamics/Evaluator.re b/src/haz3lcore/dynamics/Evaluator.re index fc4027f4d6..e1303896c2 100644 --- a/src/haz3lcore/dynamics/Evaluator.re +++ b/src/haz3lcore/dynamics/Evaluator.re @@ -4,8 +4,7 @@ open ProgramResult.Result; module EvaluatorEVMode: { type status = - | BoxedValue - | Indet + | Final | Uneval; include @@ -13,94 +12,45 @@ module EvaluatorEVMode: { type state = ref(EvaluatorState.t) and type result = (status, DHExp.t); } = { type status = - | BoxedValue - | Indet + | Final | Uneval; type result = (status, DHExp.t); - type reqstate = - | BoxedReady - | IndetReady - | IndetBlocked; + type requirement('a) = 'a; - let (&&) = (x, y) => - switch (x, y) { - | (IndetBlocked, _) => IndetBlocked - | (_, IndetBlocked) => IndetBlocked - | (IndetReady, _) => IndetReady - | (_, IndetReady) => IndetReady - | (BoxedReady, BoxedReady) => BoxedReady - }; - - type requirement('a) = (reqstate, 'a); - - type requirements('a, 'b) = (reqstate, 'a, 'b); // cumulative state, cumulative arguments, cumulative 'undo' + type requirements('a, 'b) = ('a, 'b); // cumulative arguments, cumulative 'undo' type state = ref(EvaluatorState.t); let update_test = (state, id, v) => state := EvaluatorState.add_test(state^, id, v); - let req_value = (f, _, x) => - switch (f(x)) { - | (BoxedValue, x) => (BoxedReady, x) - | (Indet, x) => (IndetBlocked, x) - | (Uneval, _) => failwith("Unexpected Uneval") - }; - - let rec req_all_value = (f, i) => - fun - | [] => (BoxedReady, []) - | [x, ...xs] => { - let (r1, x') = req_value(f, x => x, x); - let (r2, xs') = req_all_value(f, i, xs); - (r1 && r2, [x', ...xs']); - }; - - let req_final = (f, _, x) => - switch (f(x)) { - | (BoxedValue, x) => (BoxedReady, x) - | (Indet, x) => (IndetReady, x) - | (Uneval, _) => failwith("Unexpected Uneval") - }; + let req_final = (f, _, x) => f(x) |> snd; let rec req_all_final = (f, i) => fun - | [] => (BoxedReady, []) + | [] => [] | [x, ...xs] => { - let (r1, x') = req_final(f, x => x, x); - let (r2, xs') = req_all_final(f, i, xs); - (r1 && r2, [x', ...xs']); + let x' = req_final(f, x => x, x); + let xs' = req_all_final(f, i, xs); + [x', ...xs']; }; - let req_final_or_value = (f, _, x) => - switch (f(x)) { - | (BoxedValue, x) => (BoxedReady, (x, true)) - | (Indet, x) => (IndetReady, (x, false)) - | (Uneval, _) => failwith("Unexpected Uneval") - }; - - let otherwise = (_, c) => (BoxedReady, (), c); + let otherwise = (_, c) => ((), c); - let (and.) = ((r1, x1, c1), (r2, x2)) => (r1 && r2, (x1, x2), c1(x2)); + let (and.) = ((x1, c1), x2) => ((x1, x2), c1(x2)); - let (let.) = ((r, x, c), s) => - switch (r, s(x)) { - | (BoxedReady, Step({expr, state_update, is_value: true, _})) => - state_update(); - (BoxedValue, expr); - | (IndetReady, Step({expr, state_update, is_value: true, _})) => + let (let.) = ((x, c), s) => + switch (s(x)) { + | Step({expr, state_update, is_value: true, _}) => state_update(); - (Indet, expr); - | (BoxedReady, Step({expr, state_update, is_value: false, _})) - | (IndetReady, Step({expr, state_update, is_value: false, _})) => + (Final, expr); + | Step({expr, state_update, is_value: false, _}) => state_update(); (Uneval, expr); - | (BoxedReady, Constructor) => (BoxedValue, c) - | (IndetReady, Constructor) => (Indet, c) - | (IndetBlocked, _) => (Indet, c) - | (_, Value) => (BoxedValue, c) - | (_, Indet) => (Indet, c) + | Constructor + | Value + | Indet => (Final, c) }; }; module Eval = Transition(EvaluatorEVMode); @@ -108,8 +58,7 @@ module Eval = Transition(EvaluatorEVMode); let rec evaluate = (state, env, d) => { let u = Eval.transition(evaluate, state, env, d); switch (u) { - | (BoxedValue, x) => (BoxedValue, x) - | (Indet, x) => (Indet, x) + | (Final, x) => (Final, x) | (Uneval, x) => evaluate(state, env, x) }; }; @@ -120,8 +69,7 @@ let evaluate' = (env, {d, _}: Elaborator.Elaboration.t) => { let result = evaluate(state, env, d); let result = switch (result) { - | (BoxedValue, x) => BoxedValue(x |> DHExp.repair_ids) - | (Indet, x) => Indet(x |> DHExp.repair_ids) + | (Final, x) => BoxedValue(x |> DHExp.repair_ids) | (Uneval, x) => Indet(x |> DHExp.repair_ids) }; (state^, result); diff --git a/src/haz3lcore/dynamics/EvaluatorStep.re b/src/haz3lcore/dynamics/EvaluatorStep.re index 3416a46742..bbbe5c1374 100644 --- a/src/haz3lcore/dynamics/EvaluatorStep.re +++ b/src/haz3lcore/dynamics/EvaluatorStep.re @@ -237,17 +237,6 @@ module Decompose = { type requirements('a, 'b) = ('b, Result.t, ClosureEnvironment.t, 'a); type result = Result.t; - let req_value = (cont, wr, d) => { - switch (cont(d)) { - | Result.Indet => (Result.Indet, d) - | Result.BoxedValue => (Result.BoxedValue, d) - | Result.Step(objs) => ( - Result.Step(List.map(EvalObj.wrap(wr), objs)), - d, - ) - }; - }; - let (&&): (Result.t, Result.t) => Result.t = (u, v) => switch (u, v) { @@ -260,18 +249,6 @@ module Decompose = { | (BoxedValue, BoxedValue) => BoxedValue }; - let rec req_all_value' = (cont, wr, ds') => - fun - | [] => (Result.BoxedValue, []) - | [d, ...ds] => { - let (r1, v) = req_value(cont, wr(_, (ds', ds)), d); - let (r2, vs) = req_all_value'(cont, wr, [d, ...ds'], ds); - (r1 && r2, [v, ...vs]); - }; - let req_all_value = (cont, wr, ds) => { - req_all_value'(cont, wr, [], ds); - }; - let req_final = (cont, wr, d) => { ( switch (cont(d)) { @@ -284,17 +261,6 @@ module Decompose = { ); }; - let req_final_or_value = (cont, wr, d) => { - switch (cont(d)) { - | Result.Indet => (Result.BoxedValue, (d, false)) - | Result.BoxedValue => (Result.BoxedValue, (d, true)) - | Result.Step(objs) => ( - Result.Step(List.map(EvalObj.wrap(wr), objs)), - (d, false), - ) - }; - }; - let rec req_all_final' = (cont, wr, ds') => fun | [] => (Result.BoxedValue, []) @@ -354,13 +320,9 @@ module TakeStep = { type result = option(DHExp.t); // Assume that everything is either value or final as required. - let req_value = (_, _, d) => d; - let req_all_value = (_, _, ds) => ds; let req_final = (_, _, d) => d; let req_all_final = (_, _, ds) => ds; - let req_final_or_value = (_, _, d) => (d, true); - let (let.) = (rq: requirements('a, DHExp.t), rl: 'a => rule) => switch (rl(rq)) { | Step({expr, state_update, _}) => diff --git a/src/haz3lcore/dynamics/Transition.re b/src/haz3lcore/dynamics/Transition.re index c178a49dfa..4dca668399 100644 --- a/src/haz3lcore/dynamics/Transition.re +++ b/src/haz3lcore/dynamics/Transition.re @@ -18,11 +18,10 @@ open PatternMatch; to wrap the expression back up if the step couldn't be evaluated. This is followed by a series of `and. d1' = req_final(req(state, env), , )` - which indicate that in order to evaluate the step, must be final. (req_value - is also available if it needs to be a value). Note that if successful, d1' will - be the fully-evaluated version of d1. The sub-expressions are all enumerated by - the field, so i=0 indicates that it is the first sub-expression, i=1 the - second etc. + which indicate that in order to evaluate the step, must be final. Note that + if successful, d1' will be the fully-evaluated version of d1. The sub-expressions + are all enumerated by the field, so i=0 indicates that it is the first + sub-expression, i=1 the second etc. Finally, we have the Step construct that defines the actual step. Note "Step"s should be used if and only if they change the expression. If they do not change @@ -107,16 +106,6 @@ module type EV_MODE = { type requirement('a); type requirements('a, 'b); - let req_value: - (DHExp.t => result, EvalCtx.t => EvalCtx.t, DHExp.t) => - requirement(DHExp.t); - let req_all_value: - ( - DHExp.t => result, - (EvalCtx.t, (list(DHExp.t), list(DHExp.t))) => EvalCtx.t, - list(DHExp.t) - ) => - requirement(list(DHExp.t)); let req_final: (DHExp.t => result, EvalCtx.t => EvalCtx.t, DHExp.t) => requirement(DHExp.t); @@ -127,9 +116,6 @@ module type EV_MODE = { list(DHExp.t) ) => requirement(list(DHExp.t)); - let req_final_or_value: - (DHExp.t => result, EvalCtx.t => EvalCtx.t, DHExp.t) => - requirement((DHExp.t, bool)); let (let.): (requirements('a, DHExp.t), 'a => rule) => result; let (and.): @@ -257,18 +243,13 @@ module Transition = (EV: EV_MODE) => { }); } | Test(d'') => - let. _ = otherwise(env, ((d, _)) => Test(d) |> rewrap) - and. (d', is_value) = - req_final_or_value(req(state, env), d => Test(d) |> wrap_ctx, d''); + let. _ = otherwise(env, d => Test(d) |> rewrap) + and. d' = req_final(req(state, env), d => Test(d) |> wrap_ctx, d''); let result: TestStatus.t = - if (is_value) { - switch (Unboxing.unbox(Bool, d')) { - | DoesNotMatch - | IndetMatch => Indet - | Matches(b) => b ? Pass : Fail - }; - } else { - Indet; + switch (Unboxing.unbox(Bool, d')) { + | DoesNotMatch + | IndetMatch => Indet + | Matches(b) => b ? Pass : Fail }; Step({ expr: Tuple([]) |> fresh, @@ -280,8 +261,9 @@ module Transition = (EV: EV_MODE) => { | TypAp(d, tau) => let. _ = otherwise(env, d => TypAp(d, tau) |> rewrap) and. d' = - req_value(req(state, env), d => TypAp(d, tau) |> wrap_ctx, d); - switch (DHExp.term_of(d')) { + req_final(req(state, env), d => TypAp(d, tau) |> wrap_ctx, d); + let-unbox typfun = (TypFun, d'); + switch (typfun) { | TypFun(utpat, tfbody, name) => /* Rule ITTLam */ Step({ @@ -298,11 +280,7 @@ module Transition = (EV: EV_MODE) => { kind: TypFunAp, is_value: false, }) - | Cast( - d'', - {term: Forall(tp1, _), _} as t1, - {term: Forall(tp2, _), _} as t2, - ) => + | TFunCast(d'', tp1, t1, tp2, t2) => /* Rule ITTApCast */ Step({ expr: @@ -316,7 +294,6 @@ module Transition = (EV: EV_MODE) => { kind: CastTypAp, is_value: false, }) - | _ => raise(EvaluatorError.Exception(InvalidBoxedTypFun(d'))) }; | DeferredAp(d1, ds) => let. _ = otherwise(env, (d1, ds) => DeferredAp(d1, ds) |> rewrap) @@ -334,18 +311,15 @@ module Transition = (EV: EV_MODE) => { ); Value; | Ap(dir, d1, d2) => - let. _ = otherwise(env, (d1, (d2, _)) => Ap(dir, d1, d2) |> rewrap) + let. _ = otherwise(env, (d1, d2) => Ap(dir, d1, d2) |> rewrap) and. d1' = - req_value(req(state, env), d1 => Ap1(dir, d1, d2) |> wrap_ctx, d1) - and. (d2', d2_is_value) = - req_final_or_value( - req(state, env), - d2 => Ap2(dir, d1, d2) |> wrap_ctx, - d2, - ); - switch (DHExp.term_of(d1')) { + req_final(req(state, env), d1 => Ap1(dir, d1, d2) |> wrap_ctx, d1) + and. d2' = + req_final(req(state, env), d2 => Ap2(dir, d1, d2) |> wrap_ctx, d2); + let-unbox unboxed_fun = (Fun, d1'); + switch (unboxed_fun) { | Constructor(_) => Constructor - | Fun(dp, d3, Some(env'), _) => + | FunEnv(dp, d3, env') => let.match env'' = (env', matches(dp, d2')); Step({ expr: Closure(env'', d3) |> fresh, @@ -353,11 +327,7 @@ module Transition = (EV: EV_MODE) => { kind: FunAp, is_value: false, }); - | Cast( - d3', - {term: Arrow(ty1, ty2), _}, - {term: Arrow(ty1', ty2'), _}, - ) => + | FunCast(d3', ty1, ty2, ty1', ty2') => Step({ expr: Cast( @@ -371,28 +341,21 @@ module Transition = (EV: EV_MODE) => { is_value: false, }) | BuiltinFun(ident) => - if (d2_is_value) { - Step({ - expr: { - let builtin = - VarMap.lookup(Builtins.forms_init, ident) - |> OptUtil.get(() => { - /* This exception should never be raised because there is - no way for the user to create a BuiltinFun. They are all - inserted into the context before evaluation. */ - raise( - EvaluatorError.Exception(InvalidBuiltin(ident)), - ) - }); - builtin(d2'); - }, - state_update, - kind: BuiltinAp(ident), - is_value: false // Not necessarily a value because of InvalidOperations - }); - } else { - Indet; - } + let builtin = + VarMap.lookup(Builtins.forms_init, ident) + |> OptUtil.get(() => { + /* This exception should never be raised because there is + no way for the user to create a BuiltinFun. They are all + inserted into the context before evaluation. */ + raise( + EvaluatorError.Exception(InvalidBuiltin(ident)), + ) + }); + switch (builtin(d2')) { + | Some(expr) => + Step({expr, state_update, kind: BuiltinAp(ident), is_value: false}) + | None => Indet + }; | DeferredAp(d3, d4s) => let n_args = List.length( @@ -430,22 +393,6 @@ module Transition = (EV: EV_MODE) => { kind: DeferredAp, is_value: false, }); - | Cast(_) - | FailedCast(_) => Indet - | FixF(_) => - print_endline(Exp.show(d1)); - print_endline(Exp.show(d1')); - print_endline("FIXF"); - failwith("FixF in Ap"); - | _ => - Step({ - expr: { - raise(EvaluatorError.Exception(InvalidBoxedFun(d1'))); - }, - state_update, - kind: InvalidStep, - is_value: true, - }) }; | Deferral(_) => let. _ = otherwise(env, d); @@ -461,7 +408,7 @@ module Transition = (EV: EV_MODE) => { | If(c, d1, d2) => let. _ = otherwise(env, c => If(c, d1, d2) |> rewrap) and. c' = - req_value(req(state, env), c => If1(c, d1, d2) |> wrap_ctx, c); + req_final(req(state, env), c => If1(c, d1, d2) |> wrap_ctx, c); let-unbox b = (Bool, c'); Step({ expr: { @@ -478,7 +425,7 @@ module Transition = (EV: EV_MODE) => { | UnOp(Int(Minus), d1) => let. _ = otherwise(env, d1 => UnOp(Int(Minus), d1) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), c => UnOp(Int(Minus), c) |> wrap_ctx, d1, @@ -493,7 +440,7 @@ module Transition = (EV: EV_MODE) => { | UnOp(Bool(Not), d1) => let. _ = otherwise(env, d1 => UnOp(Bool(Not), d1) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), c => UnOp(Bool(Not), c) |> wrap_ctx, d1, @@ -508,7 +455,7 @@ module Transition = (EV: EV_MODE) => { | BinOp(Bool(And), d1, d2) => let. _ = otherwise(env, d1 => BinOp(Bool(And), d1, d2) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), d1 => BinOp1(Bool(And), d1, d2) |> wrap_ctx, d1, @@ -523,7 +470,7 @@ module Transition = (EV: EV_MODE) => { | BinOp(Bool(Or), d1, d2) => let. _ = otherwise(env, d1 => BinOp(Bool(Or), d1, d2) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), d1 => BinOp1(Bool(Or), d1, d2) |> wrap_ctx, d1, @@ -538,13 +485,13 @@ module Transition = (EV: EV_MODE) => { | BinOp(Int(op), d1, d2) => let. _ = otherwise(env, (d1, d2) => BinOp(Int(op), d1, d2) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), d1 => BinOp1(Int(op), d1, d2) |> wrap_ctx, d1, ) and. d2' = - req_value( + req_final( req(state, env), d2 => BinOp2(Int(op), d1, d2) |> wrap_ctx, d2, @@ -588,13 +535,13 @@ module Transition = (EV: EV_MODE) => { let. _ = otherwise(env, (d1, d2) => BinOp(Float(op), d1, d2) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), d1 => BinOp1(Float(op), d1, d2) |> wrap_ctx, d1, ) and. d2' = - req_value( + req_final( req(state, env), d2 => BinOp2(Float(op), d1, d2) |> wrap_ctx, d2, @@ -627,13 +574,13 @@ module Transition = (EV: EV_MODE) => { let. _ = otherwise(env, (d1, d2) => BinOp(String(op), d1, d2) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), d1 => BinOp1(String(op), d1, d2) |> wrap_ctx, d1, ) and. d2' = - req_value( + req_final( req(state, env), d2 => BinOp2(String(op), d1, d2) |> wrap_ctx, d2, @@ -664,7 +611,7 @@ module Transition = (EV: EV_MODE) => { and. d1' = req_final(req(state, env), d1 => Cons1(d1, d2) |> wrap_ctx, d1) and. d2' = - req_value(req(state, env), d2 => Cons2(d1, d2) |> wrap_ctx, d2); + req_final(req(state, env), d2 => Cons2(d1, d2) |> wrap_ctx, d2); let-unbox ds = (List, d2'); Step({ expr: ListLit([d1', ...ds]) |> fresh, @@ -675,13 +622,13 @@ module Transition = (EV: EV_MODE) => { | ListConcat(d1, d2) => let. _ = otherwise(env, (d1, d2) => ListConcat(d1, d2) |> rewrap) and. d1' = - req_value( + req_final( req(state, env), d1 => ListConcat1(d1, d2) |> wrap_ctx, d1, ) and. d2' = - req_value( + req_final( req(state, env), d2 => ListConcat2(d1, d2) |> wrap_ctx, d2, diff --git a/src/haz3lcore/dynamics/Unboxing.re b/src/haz3lcore/dynamics/Unboxing.re index 400620026c..07bde372b3 100644 --- a/src/haz3lcore/dynamics/Unboxing.re +++ b/src/haz3lcore/dynamics/Unboxing.re @@ -15,6 +15,17 @@ open Util; the inner lists may still have casts around them after unboxing. */ +type unboxed_tfun = + | TypFun(TPat.t, Exp.t, option(string)) + | TFunCast(DHExp.t, TPat.t, Typ.t, TPat.t, Typ.t); + +type unboxed_fun = + | Constructor(string) + | FunEnv(Pat.t, Exp.t, ClosureEnvironment.t) + | FunCast(DHExp.t, Typ.t, Typ.t, Typ.t, Typ.t) + | BuiltinFun(string) + | DeferredAp(DHExp.t, list(DHExp.t)); + type unbox_request('a) = | Int: unbox_request(int) | Float: unbox_request(float) @@ -24,7 +35,9 @@ type unbox_request('a) = | List: unbox_request(list(DHExp.t)) | Cons: unbox_request((DHExp.t, DHExp.t)) | SumNoArg(string): unbox_request(unit) - | SumWithArg(string): unbox_request(DHExp.t); + | SumWithArg(string): unbox_request(DHExp.t) + | TypFun: unbox_request(unboxed_tfun) + | Fun: unbox_request(unboxed_fun); type unboxed('a) = | DoesNotMatch @@ -135,6 +148,35 @@ let rec unbox: type a. (unbox_request(a), DHExp.t) => unboxed(a) = }; // There should be some sort of failure here when the cast doesn't go through. + /* Function-like things can look like the following when values */ + | (Fun, Constructor(name, _)) => Matches(Constructor(name)) // Perhaps we should check if the constructor actually is a function? + | (Fun, Fun(dp, d3, Some(env'), _)) => Matches(FunEnv(dp, d3, env')) + | ( + Fun, + Cast( + d3', + {term: Arrow(ty1, ty2), _}, + {term: Arrow(ty1', ty2'), _}, + ), + ) => + Matches(FunCast(d3', ty1, ty2, ty1', ty2')) + | (Fun, BuiltinFun(name)) => Matches(BuiltinFun(name)) + | (Fun, DeferredAp(d1, ds)) => Matches(DeferredAp(d1, ds)) + + /* TypFun-like things can look like the following when values */ + | (TypFun, TypFun(utpat, tfbody, name)) => + Matches(TypFun(utpat, tfbody, name)) + // Note: We might be able to handle this cast like other casts + | ( + TypFun, + Cast( + d'', + {term: Forall(tp1, _), _} as t1, + {term: Forall(tp2, _), _} as t2, + ), + ) => + Matches(TFunCast(d'', tp1, t1, tp2, t2)) + /* Any cast from unknown is indet */ | (_, Cast(_, {term: Unknown(_), _}, _)) => IndetMatch @@ -169,6 +211,8 @@ let rec unbox: type a. (unbox_request(a), DHExp.t) => unboxed(a) = | SumNoArg(_) | SumWithArg(_) => raise(EvaluatorError.Exception(InvalidBoxedSumConstructor(expr))) + | Fun => raise(EvaluatorError.Exception(InvalidBoxedFun(expr))) + | TypFun => raise(EvaluatorError.Exception(InvalidBoxedTypFun(expr))) } /* Forms that are not yet or will never be a value */ diff --git a/src/haz3lcore/dynamics/ValueChecker.re b/src/haz3lcore/dynamics/ValueChecker.re index a6e5ab30f0..c0eeb22d96 100644 --- a/src/haz3lcore/dynamics/ValueChecker.re +++ b/src/haz3lcore/dynamics/ValueChecker.re @@ -11,66 +11,35 @@ module ValueCheckerEVMode: { type state = unit; type result = t; - type requirement('a) = ('a, (result, bool)); - type requirements('a, 'b) = ('a, (result, bool)); + type requirement('a) = ('a, result); + type requirements('a, 'b) = ('a, result); - let combine = ((r1, b1), (r2, b2)) => ( + let combine = (r1, r2) => switch (r1, r2) { | (Expr, _) => Expr | (_, Expr) => Expr | (Indet, _) => Indet | (_, Indet) => Indet | (Value, Value) => Value - }, - b1 && b2, - ); + }; - let req_value = (vc, _, d) => ( - d, - switch (vc(d)) { - | Value => (Value, true) - | Indet => (Indet, false) - | Expr => (Expr, false) - }, - ); - let req_all_value = (vc, _, ds) => - List.fold_right( - ((v1, r1), (v2, r2)) => ([v1, ...v2], combine(r1, r2)), - List.map(req_value(vc, x => x), ds), - ([], (Value, true)), - ); - let req_final = (vc, _, d) => ( - d, - switch (vc(d)) { - | Value => (Value, true) - | Indet => (Indet, true) - | Expr => (Expr, false) - }, - ); + let req_final = (vc, _, d) => (d, vc(d)); let req_all_final = (vc, _, ds) => List.fold_right( ((v1, r1), (v2, r2)) => ([v1, ...v2], combine(r1, r2)), List.map(req_final(vc, x => x), ds), - ([], (Value, true)), + ([], Value), ); - let req_final_or_value = (vc, _, d) => - switch (vc(d)) { - | Value => ((d, true), (Value, true)) - | Indet => ((d, false), (Value, true)) - | Expr => ((d, false), (Value, false)) - }; - - let otherwise = (_, _) => ((), (Value, true)); + let otherwise = (_, _) => ((), Value); - let (let.) = ((v, (r, b)), rule) => - switch (b, r, rule(v)) { - | (_, _, Constructor) => r - | (_, Expr, Indet) => Expr - | (_, _, Indet) => Indet - | (_, _, Value) => Value - | (true, _, Step(_)) => Expr - | (false, _, Step(_)) => r + let (let.) = ((v, r), rule) => + switch (r, rule(v)) { + | (_, Constructor) => r + | (Expr, Indet) => Expr + | (_, Indet) => Indet + | (_, Value) => Value + | (_, Step(_)) => Expr }; let (and.) = ((v1, r1), (v2, r2)) => { From 97908fc19fe6a73728d09b7ee99fd7255ef3d093 Mon Sep 17 00:00:00 2001 From: Matt Keenan Date: Fri, 13 Dec 2024 09:25:00 -0500 Subject: [PATCH 110/281] Fix failing test --- test/Test_Evaluator.re | 64 ++++++++++++++++++------------------------ 1 file changed, 28 insertions(+), 36 deletions(-) diff --git a/test/Test_Evaluator.re b/test/Test_Evaluator.re index 24ff5af4c7..6539f59973 100644 --- a/test/Test_Evaluator.re +++ b/test/Test_Evaluator.re @@ -56,53 +56,45 @@ let tet_ap_of_hole_deferral = () => Ap( Forward, Cast( - Cast( - EmptyHole |> Exp.fresh, - Unknown(Internal) |> Typ.fresh, - Arrow( - Unknown(Internal) |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) - |> Typ.fresh, - ) - |> Exp.fresh, + EmptyHole |> Exp.fresh, + Unknown(Internal) |> Typ.fresh, Arrow( Unknown(Internal) |> Typ.fresh, Unknown(Internal) |> Typ.fresh, ) |> Typ.fresh, - Arrow( - Prod([ + ) + |> Exp.fresh, + Cast( + Tuple([ + Cast( + Float(1.) |> Exp.fresh, + Float |> Typ.fresh, Unknown(Internal) |> Typ.fresh, + ) + |> Exp.fresh, + Cast( + Bool(true) |> Exp.fresh, + Bool |> Typ.fresh, Unknown(Internal) |> Typ.fresh, + ) + |> Exp.fresh, + Cast( + Int(3) |> Exp.fresh, + Int |> Typ.fresh, Unknown(Internal) |> Typ.fresh, - ]) - |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) - |> Typ.fresh, - ) - |> Exp.fresh, - Tuple([ - Cast( - Float(1.) |> Exp.fresh, - Float |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) + ) + |> Exp.fresh, + ]) |> Exp.fresh, - Cast( - Bool(true) |> Exp.fresh, - Bool |> Typ.fresh, + Prod([ Unknown(Internal) |> Typ.fresh, - ) - |> Exp.fresh, - Cast( - Int(3) |> Exp.fresh, - Int |> Typ.fresh, Unknown(Internal) |> Typ.fresh, - ) - |> Exp.fresh, - ]) + Unknown(Internal) |> Typ.fresh, + ]) + |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) |> Exp.fresh, ) |> Exp.fresh, From ddf68bf19e581cc993b3a1b56ce5d335831acd13 Mon Sep 17 00:00:00 2001 From: Matt Keenan Date: Wed, 4 Dec 2024 13:15:56 -0500 Subject: [PATCH 111/281] Trampoline Evaluator --- src/haz3lcore/dynamics/Evaluator.re | 99 +++++++++++++++++++++-------- 1 file changed, 72 insertions(+), 27 deletions(-) diff --git a/src/haz3lcore/dynamics/Evaluator.re b/src/haz3lcore/dynamics/Evaluator.re index e1303896c2..8422eed760 100644 --- a/src/haz3lcore/dynamics/Evaluator.re +++ b/src/haz3lcore/dynamics/Evaluator.re @@ -2,6 +2,41 @@ open Transition; open ProgramResult.Result; +// This module defines the stack machine for the evaluator. +module Trampoline = { + type t('a) = + | Bind(t('b), 'b => t('a)): t('a) + | Next(unit => t('a)): t('a) + | Done('a): t('a); + + type callstack('a, 'b) = + | Finished: callstack('a, 'a) + | Continue('a => t('b), callstack('b, 'c)): callstack('a, 'c); + + let rec run: type a b. (t(b), callstack(b, a)) => a = + (t: t(b), callstack: callstack(b, a)) => ( + switch (t) { + | Bind(t, f) => (run(t, Continue(f, callstack)): a) + | Next(f) => run(f(), callstack) + | Done(x) => + switch (callstack) { + | Finished => x + | Continue(f, callstack) => run(f(x), callstack) + } + }: a + ); + + let run = run(_, Finished); + + let return = x => Done(x); + + let bind = (t, f) => Bind(t, f); + + module Syntax = { + let (let.trampoline) = (x, f) => bind(x, f); + }; +}; + module EvaluatorEVMode: { type status = | Final @@ -9,57 +44,66 @@ module EvaluatorEVMode: { include EV_MODE with - type state = ref(EvaluatorState.t) and type result = (status, DHExp.t); + type state = ref(EvaluatorState.t) and + type result = Trampoline.t((status, DHExp.t)); } = { + open Trampoline.Syntax; + type status = | Final | Uneval; - type result = (status, DHExp.t); - - type requirement('a) = 'a; - - type requirements('a, 'b) = ('a, 'b); // cumulative arguments, cumulative 'undo' + type result = Trampoline.t((status, DHExp.t)); + type requirement('a) = Trampoline.t('a); + type requirements('a, 'b) = Trampoline.t(('a, 'b)); type state = ref(EvaluatorState.t); let update_test = (state, id, v) => state := EvaluatorState.add_test(state^, id, v); - let req_final = (f, _, x) => f(x) |> snd; - - let rec req_all_final = (f, i) => - fun - | [] => [] - | [x, ...xs] => { - let x' = req_final(f, x => x, x); - let xs' = req_all_final(f, i, xs); - [x', ...xs']; - }; - - let otherwise = (_, c) => ((), c); - - let (and.) = ((x1, c1), x2) => ((x1, x2), c1(x2)); + let req_final = (f, _, x) => { + let.trampoline x' = Next(() => f(x)); + Trampoline.return(x' |> snd); + }; + let rec req_all_final = (f, i, xs) => + switch (xs) { + | [] => Trampoline.return([]) + | [x, ...xs] => + let.trampoline x' = req_final(f, x => x, x); + let.trampoline xs' = req_all_final(f, i, xs); + Trampoline.return([x', ...xs']); + }; - let (let.) = ((x, c), s) => + let otherwise = (_, c) => Trampoline.return(((), c)); + let (and.) = (t1, t2) => { + let.trampoline (x1, c1) = t1; + let.trampoline x2 = t2; + Trampoline.return(((x1, x2), c1(x2))); + }; + let (let.) = (t1, s) => { + let.trampoline (x, c) = t1; switch (s(x)) { | Step({expr, state_update, is_value: true, _}) => state_update(); - (Final, expr); + Trampoline.return((Final, expr)); | Step({expr, state_update, is_value: false, _}) => state_update(); - (Uneval, expr); + Trampoline.return((Uneval, expr)); | Constructor | Value - | Indet => (Final, c) + | Indet => Trampoline.return((Final, c)) }; + }; }; + module Eval = Transition(EvaluatorEVMode); let rec evaluate = (state, env, d) => { - let u = Eval.transition(evaluate, state, env, d); + open Trampoline.Syntax; + let.trampoline u = Eval.transition(evaluate, state, env, d); switch (u) { - | (Final, x) => (Final, x) - | (Uneval, x) => evaluate(state, env, x) + | (Final, x) => (EvaluatorEVMode.Final, x) |> Trampoline.return + | (Uneval, x) => Trampoline.Next(() => evaluate(state, env, x)) }; }; @@ -67,6 +111,7 @@ let evaluate' = (env, {d, _}: Elaborator.Elaboration.t) => { let state = ref(EvaluatorState.init); let env = ClosureEnvironment.of_environment(env); let result = evaluate(state, env, d); + let result = Trampoline.run(result); let result = switch (result) { | (Final, x) => BoxedValue(x |> DHExp.repair_ids) From cfc4180daa3ce9bb5a37b07f6c432d2700f3d97c Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 12:14:35 -0500 Subject: [PATCH 112/281] Manually curate documentation buffers to account for menhir differences in surface grammar --- test/Test_Menhir.re | 895 ++++++++++++++++++++++++++------------------ 1 file changed, 532 insertions(+), 363 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index fdb3c724d4..08239afad1 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -192,410 +192,579 @@ let single_integer_menhir = () => single_int_str, ); -let tests = - [ - parser_test("Integer Literal", Int(8) |> Exp.fresh, "8"), - parser_test("Fun", fun_exp, "fun x -> x"), - parser_test( - "String Literal", - String("Hello World") |> Exp.fresh, - "\"Hello World\"", - ), - parser_test("Bool Literal", Bool(true) |> Exp.fresh, "true"), - parser_test("Empty Hole", EmptyHole |> Exp.fresh, "?"), - parser_test("Var", Var("x") |> Exp.fresh, "x"), - parser_test( - "Parens", - Parens(Var("y") |> Exp.fresh) |> Exp.fresh, - "(y)", - ), - parser_test( - "BinOp", - BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) - |> Exp.fresh, - "4 + 5", - ), - parser_test( - "Let", - Let( - Var("x") |> Pat.fresh, - Int(5) |> Exp.fresh, - Var("x") |> Exp.fresh, - ) - |> Exp.fresh, - "let x = 5 in x", - ), - parser_test( - "Tuple", - Tuple([Int(4) |> Exp.fresh, Int(5) |> Exp.fresh]) |> Exp.fresh, - "(4, 5)" // TODO Verify with maketerm. Should this be parens or not - ), - parser_test( - "Match", - Match( - Int(4) |> Exp.fresh, - [ - (Int(1) |> Pat.fresh, String("hello") |> Exp.fresh), - (Wild |> Pat.fresh, String("world") |> Exp.fresh), - ], - ) - |> Exp.fresh, - {|case 4 +let menhir_doesnt_crash_test = (name, src) => + test_case( + name, + `Quick, + () => { + let _menhir_parsed = + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(src), + ); + (); + }, + ); + +let tests = [ + parser_test("Integer Literal", Int(8) |> Exp.fresh, "8"), + parser_test("Fun", fun_exp, "fun x -> x"), + parser_test( + "String Literal", + String("Hello World") |> Exp.fresh, + "\"Hello World\"", + ), + parser_test("Bool Literal", Bool(true) |> Exp.fresh, "true"), + parser_test("Empty Hole", EmptyHole |> Exp.fresh, "?"), + parser_test("Var", Var("x") |> Exp.fresh, "x"), + parser_test("Parens", Parens(Var("y") |> Exp.fresh) |> Exp.fresh, "(y)"), + parser_test( + "BinOp", + BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) |> Exp.fresh, + "4 + 5", + ), + parser_test( + "Let", + Let(Var("x") |> Pat.fresh, Int(5) |> Exp.fresh, Var("x") |> Exp.fresh) + |> Exp.fresh, + "let x = 5 in x", + ), + parser_test( + "Tuple", + Tuple([Int(4) |> Exp.fresh, Int(5) |> Exp.fresh]) |> Exp.fresh, + "(4, 5)" // TODO Verify with maketerm. Should this be parens or not + ), + parser_test( + "Match", + Match( + Int(4) |> Exp.fresh, + [ + (Int(1) |> Pat.fresh, String("hello") |> Exp.fresh), + (Wild |> Pat.fresh, String("world") |> Exp.fresh), + ], + ) + |> Exp.fresh, + {|case 4 | 1 => "hello" | _ => "world" end|}, - ), - parser_test( - "If", - If(Bool(true) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) - |> Exp.fresh, - "if true then 8 else 6", - ), - parser_test( - "Deferred Ap", - DeferredAp(Var("x") |> Exp.fresh, [Deferral(InAp) |> Exp.fresh]) - |> Exp.fresh, - "x(_)", - ), - parser_test( - "Cons", - Cons(Int(1) |> Exp.fresh, ListLit([]) |> Exp.fresh) |> Exp.fresh, - "1 :: []", - ), - parser_test( - "ListLit", - ListLit([ - Int(1) |> Exp.fresh, - Int(2) |> Exp.fresh, - Int(3) |> Exp.fresh, - ]) - |> Exp.fresh, - "[1, 2, 3]", - ), - menhir_only_test( - "Constructor", + ), + parser_test( + "If", + If(Bool(true) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) + |> Exp.fresh, + "if true then 8 else 6", + ), + parser_test( + "Deferred Ap", + DeferredAp(Var("x") |> Exp.fresh, [Deferral(InAp) |> Exp.fresh]) + |> Exp.fresh, + "x(_)", + ), + parser_test( + "Cons", + Cons(Int(1) |> Exp.fresh, ListLit([]) |> Exp.fresh) |> Exp.fresh, + "1 :: []", + ), + parser_test( + "ListLit", + ListLit([ + Int(1) |> Exp.fresh, + Int(2) |> Exp.fresh, + Int(3) |> Exp.fresh, + ]) + |> Exp.fresh, + "[1, 2, 3]", + ), + menhir_only_test("Unit", Tuple([]) |> Exp.fresh, "()"), + menhir_only_test( + "Constructor", + Constructor("A", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, + "A", + ), + menhir_only_test( + "Constructor cast", + Cast( Constructor("A", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, - "A", - ), - menhir_only_test( - "Constructor cast", + Unknown(Internal) |> Typ.fresh, + Int |> Typ.fresh, + ) + |> Exp.fresh, + "A : Int", + ), + menhir_only_test( + "Constructor of specific sum type", + Constructor("A", Int |> Typ.fresh) |> Exp.fresh, + "A ~ Int", + ), + // TODO Fix for the tests below + menhir_only_test( + "Constructor with Type Variable", + Constructor("A", Var("T") |> Typ.fresh) |> Exp.fresh, + "A ~ T", + ), + parser_test( + "Type Variable", + Let( Cast( - Constructor("A", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, + Var("x") |> Pat.fresh, + Var("T") |> Typ.fresh, Unknown(Internal) |> Typ.fresh, - Int |> Typ.fresh, - ) - |> Exp.fresh, - "A : Int", - ), - menhir_only_test( - "Constructor of specific sum type", - Constructor("A", Int |> Typ.fresh) |> Exp.fresh, - "A ~ Int", - ), - // TODO Fix for the tests below - menhir_only_test( - "Constructor with Type Variable", - Constructor("A", Var("T") |> Typ.fresh) |> Exp.fresh, - "A ~ T", - ), - parser_test( - "Type Variable", - Let( - Cast( - Var("x") |> Pat.fresh, - Var("T") |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) - |> Pat.fresh, - EmptyHole |> Exp.fresh, - Var("x") |> Exp.fresh, - ) - |> Exp.fresh, - "let x : T = ? in x", - ), - parser_test( - "Type Alias", - TyAlias(Var("x") |> TPat.fresh, Int |> Typ.fresh, Int(1) |> Exp.fresh) - |> Exp.fresh, - "type x = Int in 1", - ), - parser_test( - "Test", - Test( - BinOp(Int(Equals), Int(3) |> Exp.fresh, Int(3) |> Exp.fresh) - |> Exp.fresh, - ) - |> Exp.fresh, - "test 3 == 3 end", - ), - parser_test( - "Filter", - Filter( - Filter({act: (Eval, All), pat: Int(3) |> Exp.fresh}), - Int(3) |> Exp.fresh, ) + |> Pat.fresh, + EmptyHole |> Exp.fresh, + Var("x") |> Exp.fresh, + ) + |> Exp.fresh, + "let x : T = ? in x", + ), + parser_test( + "Type Alias", + TyAlias(Var("x") |> TPat.fresh, Int |> Typ.fresh, Int(1) |> Exp.fresh) + |> Exp.fresh, + "type x = Int in 1", + ), + parser_test( + "Test", + Test( + BinOp(Int(Equals), Int(3) |> Exp.fresh, Int(3) |> Exp.fresh) |> Exp.fresh, - "eval 3 in 3" // TODO Use other filter commands - ), - parser_test( - "List Concat", - ListConcat( - ListLit([Int(1) |> Exp.fresh, Int(2) |> Exp.fresh]) |> Exp.fresh, - ListLit([Int(3) |> Exp.fresh, Int(4) |> Exp.fresh]) |> Exp.fresh, - ) + ) + |> Exp.fresh, + "test 3 == 3 end", + ), + parser_test( + "Filter", + Filter( + Filter({act: (Eval, All), pat: Int(3) |> Exp.fresh}), + Int(3) |> Exp.fresh, + ) + |> Exp.fresh, + "eval 3 in 3" // TODO Use other filter commands + ), + parser_test( + "List Concat", + ListConcat( + ListLit([Int(1) |> Exp.fresh, Int(2) |> Exp.fresh]) |> Exp.fresh, + ListLit([Int(3) |> Exp.fresh, Int(4) |> Exp.fresh]) |> Exp.fresh, + ) + |> Exp.fresh, + "[1, 2] @ [3, 4]", + ), + parser_test( + "times and divide precendence", + BinOp( + Int(Times), + Int(1) |> Exp.fresh, + BinOp(Int(Divide), Int(2) |> Exp.fresh, Int(3) |> Exp.fresh) |> Exp.fresh, - "[1, 2] @ [3, 4]", - ), - parser_test( - "times and divide precendence", - BinOp( - Int(Times), - Int(1) |> Exp.fresh, - BinOp(Int(Divide), Int(2) |> Exp.fresh, Int(3) |> Exp.fresh) - |> Exp.fresh, - ) + ) + |> Exp.fresh, + "1 * 2 / 3", + ), + parser_test( + "plus and minus precendence", + BinOp( + Int(Plus), + BinOp(Int(Minus), Int(1) |> Exp.fresh, Int(2) |> Exp.fresh) |> Exp.fresh, - "1 * 2 / 3", - ), - parser_test( - "plus and minus precendence", + Int(3) |> Exp.fresh, + ) + |> Exp.fresh, + "1 - 2 + 3", + ), + parser_test( + "Integer Ops", + BinOp( + Int(GreaterThanOrEqual), BinOp( - Int(Plus), - BinOp(Int(Minus), Int(1) |> Exp.fresh, Int(2) |> Exp.fresh) + Int(Minus), + BinOp( + Int(Plus), + UnOp(Int(Minus), Int(1) |> Exp.fresh) |> Exp.fresh, + Int(2) |> Exp.fresh, + ) |> Exp.fresh, - Int(3) |> Exp.fresh, - ) - |> Exp.fresh, - "1 - 2 + 3", - ), - parser_test( - "Integer Ops", - BinOp( - Int(GreaterThanOrEqual), BinOp( - Int(Minus), - BinOp( - Int(Plus), - UnOp(Int(Minus), Int(1) |> Exp.fresh) |> Exp.fresh, - Int(2) |> Exp.fresh, - ) - |> Exp.fresh, + Int(Divide), + Int(3) |> Exp.fresh, BinOp( - Int(Divide), - Int(3) |> Exp.fresh, - BinOp( - Int(Times), - Int(4) |> Exp.fresh, - BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) - |> Exp.fresh, - ) + Int(Times), + Int(4) |> Exp.fresh, + BinOp(Int(Power), Int(5) |> Exp.fresh, Int(6) |> Exp.fresh) |> Exp.fresh, ) |> Exp.fresh, ) |> Exp.fresh, - Int(8) |> Exp.fresh, ) |> Exp.fresh, - "-1 + 2 - 3 / 4 * 5 ** 6 >= 8", - ), - parser_test("Float", Float(1.) |> Exp.fresh, "1."), - parser_test( - "Float Ops", + Int(8) |> Exp.fresh, + ) + |> Exp.fresh, + "-1 + 2 - 3 / 4 * 5 ** 6 >= 8", + ), + parser_test("Float", Float(1.) |> Exp.fresh, "1."), + parser_test( + "Float Ops", + BinOp( + Float(LessThan), BinOp( - Float(LessThan), + Float(Minus), + Float(2.) |> Exp.fresh, BinOp( - Float(Minus), - Float(2.) |> Exp.fresh, + Float(Divide), + Float(3.) |> Exp.fresh, BinOp( - Float(Divide), - Float(3.) |> Exp.fresh, + Float(Times), + Float(4.) |> Exp.fresh, BinOp( - Float(Times), - Float(4.) |> Exp.fresh, - BinOp( - Float(Power), - Float(5.) |> Exp.fresh, - Float(6.) |> Exp.fresh, - ) - |> Exp.fresh, + Float(Power), + Float(5.) |> Exp.fresh, + Float(6.) |> Exp.fresh, ) |> Exp.fresh, ) |> Exp.fresh, ) |> Exp.fresh, - Float(8.) |> Exp.fresh, - ) - |> Exp.fresh, - "2. -. 3. /. 4. *. 5. **. 6. <. 8.", - ), - parser_test( - "Let binding with type ascription", - Let( - Cast( - Var("x") |> Pat.fresh, - Int |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) - |> Pat.fresh, - Int(5) |> Exp.fresh, - Var("x") |> Exp.fresh, - ) - |> Exp.fresh, - "let (x: Int) = 5 in x", - ), - menhir_only_test( - "named_function", - Fun( - Pat.Var("x") |> Pat.fresh, - BinOp(Int(Plus), Var("x") |> Exp.fresh, Int(5) |> Exp.fresh) - |> Exp.fresh, - None, - Some("f"), - ) - |> Exp.fresh, - "named_fun f x -> x + 5", - ), - parser_test( - "basic sum type", - Let( - Cast( - Var("x") |> Pat.fresh, - Sum([ - Variant("A", [], None), - Variant("B", [], None), - Variant("C", [], Some(Int |> Typ.fresh)), - ]) - |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) - |> Pat.fresh, - Ap( - Forward, - Constructor("C", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, - Int(7) |> Exp.fresh, - ) - |> Exp.fresh, - Var("x") |> Exp.fresh, - ) - |> Exp.fresh, - "let x : +A +B +C(Int) = C(7) in x", - ), - menhir_maketerm_equivalent_test("Empty Type Hole", "let g: ? = 7 in g"), - menhir_maketerm_equivalent_test( - "Pattern with type ascription", - "fun (b : Bool) -> b", - ), - menhir_only_test( - "Type Hole in arrow cast", - Fun( - Cast( - Var("b") |> Pat.fresh, - Parens( - Arrow( - Unknown(Hole(EmptyHole)) |> Typ.fresh, - Unknown(Hole(EmptyHole)) |> Typ.fresh, - ) - |> Typ.fresh, - ) - |> Typ.fresh, - Unknown(Internal) |> Typ.fresh, - ) - |> Pat.fresh, - EmptyHole |> Exp.fresh, - None, - None, ) |> Exp.fresh, - "fun (b : ? -> ?) -> ?", - ), - menhir_only_test( - "multiargument function", - Ap( - Forward, - Var("f") |> Exp.fresh, - Tuple([Int(1) |> Exp.fresh, Int(2) |> Exp.fresh]) |> Exp.fresh, + Float(8.) |> Exp.fresh, + ) + |> Exp.fresh, + "2. -. 3. /. 4. *. 5. **. 6. <. 8.", + ), + parser_test( + "Let binding with type ascription", + Let( + Cast( + Var("x") |> Pat.fresh, + Int |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, ) + |> Pat.fresh, + Int(5) |> Exp.fresh, + Var("x") |> Exp.fresh, + ) + |> Exp.fresh, + "let (x: Int) = 5 in x", + ), + menhir_only_test( + "named_function", + Fun( + Pat.Var("x") |> Pat.fresh, + BinOp(Int(Plus), Var("x") |> Exp.fresh, Int(5) |> Exp.fresh) |> Exp.fresh, - "f(1, 2)", - ), - menhir_only_test( - "Sum type definition without leading plus", - TyAlias( - Var("GoodSum") |> TPat.fresh, + None, + Some("f"), + ) + |> Exp.fresh, + "named_fun f x -> x + 5", + ), + parser_test( + "basic sum type", + Let( + Cast( + Var("x") |> Pat.fresh, Sum([ Variant("A", [], None), Variant("B", [], None), Variant("C", [], Some(Int |> Typ.fresh)), ]) |> Typ.fresh, - Int(1) |> Exp.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Pat.fresh, + Ap( + Forward, + Constructor("C", Unknown(Internal) |> Typ.fresh) |> Exp.fresh, + Int(7) |> Exp.fresh, ) |> Exp.fresh, - "type GoodSum = A + B + C(Int) in 1", - ), - menhir_maketerm_equivalent_test( - "partial sum type", - "type Partial = Ok(?) + ? in ?", - ), - ] - @ { - let strip_comments = str => { - let re = Str.regexp("#[^#]*#"); - Str.global_replace(re, "", str); - }; - let replace_holes = str => { - // List of lines in doc buffers that are not correctly formed - let failing_parse_strings = [ - "type ? = badTypeToken in", - "type NotASum = NotInSum(Bool) in", - "+ notvalid", - "type Bool = ? in", - "+ Int(Int)", - "+ Int(Int)", - "+ (?)(Int)", - "+ A(Bool)(Int)", - "type (?, ?) = ? in", - "+ Bool", - ]; - let remove_failing_parse = str => { - List.fold_left( - (acc, s) => Str.global_replace(Str.regexp_string(s), "", acc), - str, - failing_parse_strings, - ); - }; - - str - |> Str.global_replace(Str.regexp("= in"), "= ? in", _) - |> remove_failing_parse - |> Str.global_replace(Str.regexp("^ *\n"), "", _); - }; - let (_, slides: list((string, PersistentZipper.t)), _) = - Haz3lweb.Init.startup.documentation; - List.map( - ((name, slide): (string, PersistentZipper.t)) => { - test_case( - "Documentation buffer: " ++ name, - `Quick, - () => { - let cleaned_source = - replace_holes(strip_comments(slide.backup_text)); - print_endline(cleaned_source); - let _menhir_parsed = - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(cleaned_source), - ); - (); - // alco_check( - // "Menhir parse does not match MakeTerm", - // make_term_parse(slide.backup_text), - // menhir_parsed, - // ); - }, + Var("x") |> Exp.fresh, + ) + |> Exp.fresh, + "let x : +A +B +C(Int) = C(7) in x", + ), + menhir_maketerm_equivalent_test("Empty Type Hole", "let g: ? = 7 in g"), + menhir_maketerm_equivalent_test( + "Pattern with type ascription", + "fun (b : Bool) -> b", + ), + menhir_only_test( + "Type Hole in arrow cast", + Fun( + Cast( + Var("b") |> Pat.fresh, + Parens( + Arrow( + Unknown(Hole(EmptyHole)) |> Typ.fresh, + Unknown(Hole(EmptyHole)) |> Typ.fresh, + ) + |> Typ.fresh, ) - }, - slides, - ); - }; + |> Typ.fresh, + Unknown(Internal) |> Typ.fresh, + ) + |> Pat.fresh, + EmptyHole |> Exp.fresh, + None, + None, + ) + |> Exp.fresh, + "fun (b : ? -> ?) -> ?", + ), + menhir_only_test( + "multiargument function", + Ap( + Forward, + Var("f") |> Exp.fresh, + Tuple([Int(1) |> Exp.fresh, Int(2) |> Exp.fresh]) |> Exp.fresh, + ) + |> Exp.fresh, + "f(1, 2)", + ), + menhir_maketerm_equivalent_test( + "partial sum type", + "type Partial = +Ok(?) + ? in ?", + ), + menhir_doesnt_crash_test("Function with type variable", "fun (x : a) -> x"), + menhir_doesnt_crash_test( + "Altered Documentation Buffer: Basic Reference", + {| +let empty_hole = ? in + +let non_empty_hole : Int = true in + +let bool: Bool = true in +let operators = !true && false || true in +let conditional = if !true then 1 else 2 in + +let num: Int = 1 in +let arithmetic = -num*1 + 2/3 - 4**5 in +let comparison = + (0 == 0, 0 < 1, 1 <= 1, 2 > 1, 1 >= 1) +in + +let float: Float = 0.1 in +let artihmetic = 0. *. 1. +. 2. /. 3. -. 4. **. 5. in +let comparison = + (0. ==. 0., 0. <. 1., 1. <=. 1., 2. >. 1., 1. >=. 1.) +in + +let string = "Hello, world!" in +let concatenation = string ++ " Goodbye." in +let comparison = string$== "Hello, world!" in + +let tuple : (Int, Bool, (Bool, Int)) = +(1, true, (false, 3)) in +let (a, b, (c, d)) = tuple in + +let y : (Int, Int, Int) -> Int = +fun (m, x, b) -> m * x + b in + +let double_recursively : Int -> Int = + fun n -> + if n == 0 + then 0 + else double_recursively(n - 1) + 2 +in + +let (even : Int -> Bool, odd : Int -> Bool) = + (fun n -> if n == 0 then true else odd(n - 1), + fun n -> if n == 0 then false else even(n - 1)) +in + +let empty_list : [Int] = [] in +let non_empty_list : [Int] = 1::2::3::[] in +let list_literals : [Int] = [1, 2, 3] in +let length : [Int] -> Int = + fun xs -> + case xs + | [] => 0 + | hd::tl => 1 + length(tl) + end +in +let has_at_least_two_elements : [Int] -> Bool = + fun xs -> + case xs + | [] => false + | hd::[] => false + | a::b::[] => true + end +in + +type Exp = + + Var(String) + + Lam(String, Exp) ++ Ap(Exp, Exp) in +let exp_equal: (Exp, Exp) -> Bool = + fun es -> + case es + | (Var(x), Var(y)) => x$== y + | (Lam((x1, e1)), Lam((x2, e2))) => x1$== x2 && exp_equal(e1, e2) + | (Ap((e1, e2)), Ap((e3, e4))) => exp_equal(e1, e3) && exp_equal(e2, e4) + | _ => false + end +in + +let poly_id: (forall a -> a -> a) = + (typfun a -> (fun (x : a) -> x)) +in +let apply_both: +forall a -> forall b -> (forall c -> c -> c) -> ((a, b) -> (a, b)) = + typfun a -> typfun b -> + fun (f : forall c -> (c -> c)) -> + fun ((x, y) : (a, b)) -> (f@(x), f@(y)) +in +let list_length: forall a -> [a] -> Int = + typfun a -> fun (l : [a]) -> + case l + | [] => 0 + | hd::tl => 1 + list_length@(tl) + end +in + +test 2 + 2 == 4 end; +test 3 + 3 == 6 end; +test 2 + 2 == 5 end; + +2 + 2 + |}, + ), + menhir_doesnt_crash_test( + "Altered Documentation Buffer: Projectors", + {| +let fold = (((((((((((()))))))))))) in +let folds: (Int -> Bool) = ? in +let guard: Bool = true in +let phase: Int = 44 in +let float: Float = 79.00 in +let (a:Int, f: Float) = (true, 28) in +let _ = "" in +let __ = "" in +let ___ = "a" in +let ____ = "shift" in +let _____ = "malicious" in +let ______ = "a shift malicious" in +let box: Int = "malicious" in +if true && 23 < int_of_float(51.00) +then ______ else "its: " ++ box |}, + ), + menhir_doesnt_crash_test( + "Altered Documentation Buffer: Types & Static Errors", + {| +let _ = unbound in +let Undefined = Undefined in +let true = 2 in + +let ? = if true then 1 else 1. in +let _ = if true then 1 else 1. in +let _: ? = if true then 1 else 1. in +let _: Int = if true then 1 else 1. in +let _: Fake = if true then 1 else true in +let (_, _) = if true then 1 else 1. in +let (_, _) = ((if true then 1 else 1.),?) in +let (_: ?, _) = ((if true then 1 else 1.),?) in +let [_] = [(if true then 1 else 1.)] in +let [_] = (if true then 1 else 1.) in + +(?)(if true then 1 else 1.); +1(if true then 1 else 1.); +(1)(if true then 1 else 1.); +(fun ? -> ?)(if true then 1 else 1.); +(fun _ -> ?)(if true then 1 else 1.); +(fun (_: ?) -> ?)(if true then 1 else 1.); +(fun (_: Int) -> ?)(if true then 1 else 1.); + +let _ = fun x -> if true then 1 else 1. in +let _: ? = fun x -> if true then 1 else 1. in +let _: ? -> ? = fun x -> if true then 1 else 1. in +let _: ? -> Int = fun x -> if true then 1 else 1. in +let _: ? -> [?] = fun x -> if true then 1 else 1. in + +(?)::[(if true then 1 else 1.)]; +1::[(if true then 1 else 1.)]; +(1, 1)::[(if true then 1 else 1.)]; + +let ? = [1, 1., true] in +let _ = [1, 1., true] in +let _: ? = [1, 1., true] in +let _: [?] = [1, 1., true] in +let _: [Int] = [1, 1., true] in + +let _: [Int] = 1::[2] in +let _: [Int] = 1.0::[2] in +let _: [Int] = 1::[2.0] in +"BYE" +|}, + ), + menhir_doesnt_crash_test( + "Altered Documentation Buffer: adt dynamics", + {| +type Exp = + + Var(String) + + Lam(String, Exp) + + Ap(Exp, Exp) in + +let exp_equal: (Exp, Exp) -> Bool = + fun es -> + case es + | (Var(x), Var(y)) => x$== y + | (Lam((x1, e1)), Lam((x2, e2))) => x1$== x2 && exp_equal(e1, e2) + | (Ap((e1, e2)), Ap((e3, e4))) => exp_equal(e1, e3) && exp_equal(e2, e4) + | _ => false end in + +let subst: (Exp, String, Exp) -> Exp= + fun (v, name, f) -> + case f + | Var(n) => + (if n$== name then v else f) + | Lam((x, body)) => + Lam(x, subst(v,name, body)) + | Ap((e1,e2)) => + Ap(subst(v, name, e1), subst(v, name, e2)) end in + +type Result = + + Error(String) + + Ok(Exp) +in + +let result_equal: (Result, Result) -> Bool = + fun rs -> + case rs + | (Ok(e1), Ok(e2)) => exp_equal(e1, e2) + | (Error(e1), Error(e2)) => e1$== e2 +| _ => false end in + +let go: Exp -> Result = + fun f -> + case f + | Var(n) => Error("Free Variable") + | Lam((x, body)) => Ok(Lam(x, body)) + | Ap((e1,e2)) => + case go(e1) + | Ok(Lam((x, body)))=> + case go(e2) + | Error(err) => Error(err) + | Ok(arg) => go(subst(arg, x, body)) end +| _ => Error("Not a Function") end end in + +test result_equal( + go(Var("yo")), +Error("Free Variable")) end; + +test result_equal( + go(Ap(Var("no"), Lam("bro", Var("bro")))), +Error("Not a Function")) end; + +test result_equal( + go(Lam("yo", Var("yo"))), +Ok(Lam("yo", Var("yo")))) end; + +test result_equal( + go(Ap(Lam("yo", Var("yo")), Lam("bro", Var("bro")))), +Ok(Lam("bro", Var("bro")))) end +|}, + ), +]; From be85171b306cf1d5d1229b0edcfec843f9f0c4af Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 12:14:57 -0500 Subject: [PATCH 113/281] Add forall to AST --- src/haz3lmenhir/AST.re | 15 ++++++++------- src/haz3lmenhir/Conversion.re | 1 + 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 610d225301..d2d3979063 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -75,6 +75,12 @@ type typ_provenance = | Internal | EmptyHole; +[@deriving (show({with_path: false}), sexp)] +type tpat = + | InvalidTPat(string) + | EmptyHoleTPat + | VarTPat(string); + [@deriving (show({with_path: false}), sexp)] type typ = | IntType @@ -89,7 +95,8 @@ type typ = | ArrayType(typ) | ArrowType(typ, typ) | TypVar(string) - | InvalidTyp(string); + | InvalidTyp(string) + | ForallType(tpat, typ); [@deriving (show({with_path: false}), sexp)] type pat = @@ -118,12 +125,6 @@ type deferral_pos = | InAp | OutsideAp; -[@deriving (show({with_path: false}), sexp)] -type tpat = - | InvalidTPat(string) - | EmptyHoleTPat - | VarTPat(string); - [@deriving (show({with_path: false}), sexp)] type exp = | Int(int) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 2448ddf8ff..a9add978e0 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -262,6 +262,7 @@ and Typ: { let converted_terms = constructormap_of_sumterm_list(terms^); Sum(converted_terms); | SumTerm(_) => raise(Failure("SumTerm conversion not possible")) + | ForallType(tp, t) => Forall(TPat.of_menhir_ast(tp), of_menhir_ast(t)) }; } and constructormap_of_sumterm_list = From 7904db5edf2d01e854169e85790c06d751b49c4d Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 12:15:30 -0500 Subject: [PATCH 114/281] Add forall, unit exp to parser - Also revert to only preceding + variant types --- src/haz3lmenhir/Lexer.mll | 1 + src/haz3lmenhir/Parser.mly | 17 ++++++++--------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index e31c8e83d6..c2df65649d 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -127,6 +127,7 @@ rule token = | "tp" {TP_TPAT} | "e" {E_EXP} | "named_fun" {NAMED_FUN} + | "forall" {FORALL} | identifier as i { IDENT(i) } | constructor_ident as i { CONSTRUCTOR_IDENT(i)} | eof { EOF } diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 46950564f5..59c9b1cdc0 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -12,6 +12,7 @@ open AST %token E_EXP %token TILDE %token NAMED_FUN +%token FORALL %token UNDEF %token SEXP_STRING %token DOLLAR_SIGN @@ -214,18 +215,14 @@ binExp: | i = CONSTRUCTOR_IDENT { SumTerm(i, None) } | QUESTION { UnknownType(EmptyHole) } - -plusLeadingSumTyp: - | PLUS; s = sumTerm; { SumTyp(s, None) } %prec SUM_TYP - | PLUS; s = sumTerm; t = plusLeadingSumTyp { SumTyp(s, Some(t)) } - +// We don't support sum types without the leading plus in the parser syntax sumTyp: - | s = plusLeadingSumTyp; { s } - | s = sumTerm; t = plusLeadingSumTyp { SumTyp(s, Some(t)) } + | PLUS; s = sumTerm; { SumTyp(s, None) } %prec SUM_TYP + | PLUS; s = sumTerm; t = sumTyp { SumTyp(s, Some(t)) } - typ: | c = CONSTRUCTOR_IDENT { TypVar(c) } + | c = IDENT { TypVar(c) } | QUESTION; T_TYP; s = STRING { InvalidTyp(s) } | INT_TYPE { IntType } | FLOAT_TYPE { FloatType } @@ -234,6 +231,7 @@ typ: | UNKNOWN; INTERNAL { UnknownType(Internal) } | QUESTION { UnknownType(EmptyHole) } | UNIT { UnitType } + | FORALL; a = tpat; DASH_ARROW; t = typ { ForallType(a, t) } | t = tupleType { t } | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } | t1 = typ; DASH_ARROW; t2 = typ { ArrowType(t1, t2) } @@ -263,7 +261,7 @@ pat: | p1 = pat; COLON; t1 = typ; { CastPat(p1, t1, UnknownType(Internal)) } (* | p1 = pat; AS; p2 = pat; { AsPat(p1, p2) } *) | p1 = pat; CONS; p2 = pat { ConsPat(p1, p2) } - | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } + | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } // TODO See if we can do multi arg pat ap without extra parens | p = nonAscriptingPat; { p } @@ -310,6 +308,7 @@ exp: | s = STRING { String s} | OPEN_PAREN; e = exp; CLOSE_PAREN { e } | OPEN_PAREN; e = exp; COMMA; l = separated_list(COMMA, exp); CLOSE_PAREN { TupleExp(e :: l) } + | UNIT { TupleExp([]) } | c = case { c } | OPEN_SQUARE_BRACKET; e = separated_list(COMMA, exp); CLOSE_SQUARE_BRACKET { ListExp(e) } | f = exp; OPEN_PAREN; a = exp; CLOSE_PAREN { ApExp(f, a) } From f4508509c7e67552e9d3cec0d1c0462357f43554 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 13:57:41 -0500 Subject: [PATCH 115/281] Make assertion more restrictive --- test/Test_Menhir.re | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index e619e058e5..1c496cdddc 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -524,7 +524,10 @@ let tests = [ "partial sum type", "type Partial = +Ok(?) + ? in ?", ), - menhir_doesnt_crash_test("Function with type variable", "fun (x : a) -> x"), + menhir_maketerm_equivalent_test( + "Function with type variable", + "fun (x : a) -> x", + ), menhir_doesnt_crash_test( "Altered Documentation Buffer: Basic Reference", {| From f96e3d2fe2fa4151ee84f4a3f502b35501d5fd37 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 14:47:25 -0500 Subject: [PATCH 116/281] Fix sequence precedence --- src/haz3lmenhir/Parser.mly | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index db28ef9150..345eb27338 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -110,6 +110,7 @@ open AST %nonassoc IF_EXP %nonassoc LET_EXP +%right SEMI_COLON %right SUM_TYP @@ -144,7 +145,6 @@ open AST %left TILDE (* %left COMMA *) %left AT_SYMBOL -%left SEMI_COLON %left IN %left DOLLAR_SIGN %left L_NOT L_AND L_OR From e7f8e61b75876393c0fdac6a935d5cecbfef34ac Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 14:53:50 -0500 Subject: [PATCH 117/281] Fix and ap precedence --- src/haz3lmenhir/Parser.mly | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 345eb27338..9ad6599728 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -138,17 +138,18 @@ open AST %left OPEN_CURLY -(* Other *) -%left CONS -%left OPEN_PAREN -%left QUESTION -%left TILDE (* %left COMMA *) %left AT_SYMBOL %left IN %left DOLLAR_SIGN %left L_NOT L_AND L_OR +(* Other *) +%left CONS +%left OPEN_PAREN +%left QUESTION +%left TILDE + %left STRING_CONCAT STRING_EQUAL From aa34712b4acacc4658a61872d7a0a405449c6fef Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 14:59:57 -0500 Subject: [PATCH 118/281] Stripped parens in tests --- test/Test_Menhir.re | 24 +++++++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 1c496cdddc..0ed96f9569 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -15,9 +15,22 @@ let exp_typ = let alco_check = exp_typ |> Alcotest.check; +let strip_parens = + Exp.map_term( + ~f_exp= + (cont: TermBase.exp_t => TermBase.exp_t, e2: TermBase.exp_t) => + switch (e2.term) { + | Parens(e) => cont(e) + | _ => cont(e2) + }, + _, + ); + // Existing recovering parser let make_term_parse = (s: string) => - MakeTerm.from_zip_for_sem(Option.get(Printer.zipper_of_string(s))).term; + strip_parens( + MakeTerm.from_zip_for_sem(Option.get(Printer.zipper_of_string(s))).term, + ); let menhir_matches = (exp: Term.Exp.t, actual: string) => alco_check( @@ -528,6 +541,15 @@ let tests = [ "Function with type variable", "fun (x : a) -> x", ), + menhir_maketerm_equivalent_test("Sequence addition precedence", "1+2;3"), + menhir_maketerm_equivalent_test( + "And app precedence", + "exp_equal(e1, e3) && exp_equal(e2, e4)", + ), + menhir_maketerm_equivalent_test( + "Negation precedence with multiplication", + "-num*1", + ), menhir_doesnt_crash_test( "Altered Documentation Buffer: Basic Reference", {| From 773583f0e85e6a31c51b1d549bdbe0d66858f150 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 15:02:41 -0500 Subject: [PATCH 119/281] Fix negation precedence --- src/haz3lmenhir/Parser.mly | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 9ad6599728..783a99a3c1 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -149,6 +149,7 @@ open AST %left OPEN_PAREN %left QUESTION %left TILDE +%nonassoc UMINUS /* Unary minus (prefix) */ @@ -294,7 +295,7 @@ tpat: unExp: | DOLLAR_SIGN; e = exp {UnOp(Meta(Unquote), e)} - | MINUS; e = exp {UnOp(Int(Minus), e)} + | MINUS; e = exp {UnOp(Int(Minus), e)} %prec UMINUS | L_NOT; e = exp {UnOp(Bool(Not), e)} From 5bb8b1878966ff1506e251c01ae19ffc001fb9f5 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 15:12:27 -0500 Subject: [PATCH 120/281] Stop having singleton tuple types --- src/haz3lmenhir/Conversion.re | 1 + 1 file changed, 1 insertion(+) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 8cb01f017a..233af093a2 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -238,6 +238,7 @@ and Typ: { | EmptyHole => Unknown(Hole(EmptyHole)) } | TypVar(s) => Var(s) + | TupleType([t]) => Parens(of_menhir_ast(t)) | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) | ArrayType(t) => List(of_menhir_ast(t)) | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) From 97dd32d42a11d15999224352187bddbf6c0a5883 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 15:23:44 -0500 Subject: [PATCH 121/281] Fix cons association --- src/haz3lmenhir/Parser.mly | 3 ++- test/Test_Menhir.re | 19 ++++++++++++++++--- 2 files changed, 18 insertions(+), 4 deletions(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 783a99a3c1..5735f67eff 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -145,7 +145,7 @@ open AST %left L_NOT L_AND L_OR (* Other *) -%left CONS +%right CONS %left OPEN_PAREN %left QUESTION %left TILDE @@ -208,6 +208,7 @@ program: binExp: | e1 = exp; b = binOp; e2 = exp { BinExp (e1, b, e2) } +// Currently singleton tuples are still TupleTypes and we then convert to singleton in Conversion %inline tupleType: | OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { TupleType(types) } diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 0ed96f9569..2bedf4c954 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -23,6 +23,18 @@ let strip_parens = | Parens(e) => cont(e) | _ => cont(e2) }, + ~f_pat= + (cont, e2) => + switch (e2.term) { + | Parens(e) => cont(e) + | _ => cont(e2) + }, + ~f_typ= + (cont, e2) => + switch (e2.term) { + | Parens(e) => cont(e) + | _ => cont(e2) + }, _, ); @@ -550,6 +562,7 @@ let tests = [ "Negation precedence with multiplication", "-num*1", ), + menhir_maketerm_equivalent_test("Concatenation association", "1::2::3::[]"), menhir_doesnt_crash_test( "Altered Documentation Buffer: Basic Reference", {| @@ -629,16 +642,16 @@ let exp_equal: (Exp, Exp) -> Bool = end in -let poly_id: (forall a -> a -> a) = +let poly_id: (forall a -> (a -> a)) = (typfun a -> (fun (x : a) -> x)) in let apply_both: -forall a -> forall b -> (forall c -> c -> c) -> ((a, b) -> (a, b)) = +forall a -> forall b -> (forall c -> (c -> c)) -> ((a, b) -> (a, b)) = typfun a -> typfun b -> fun (f : forall c -> (c -> c)) -> fun ((x, y) : (a, b)) -> (f@(x), f@(y)) in -let list_length: forall a -> [a] -> Int = +let list_length: forall a -> ([a] -> Int) = typfun a -> fun (l : [a]) -> case l | [] => 0 From abfccdf924aa7f7ea07e1598cdc86175b46b94c8 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 15:37:33 -0500 Subject: [PATCH 122/281] Fix arrow associativity --- src/haz3lmenhir/Parser.mly | 2 +- test/Test_Menhir.re | 22 +++++++++++----------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 5735f67eff..6a47c98ef9 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -116,7 +116,7 @@ open AST %left COLON -%left DASH_ARROW +%right DASH_ARROW (* Int op precedences *) %left DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 2bedf4c954..d73779b007 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -18,22 +18,22 @@ let alco_check = exp_typ |> Alcotest.check; let strip_parens = Exp.map_term( ~f_exp= - (cont: TermBase.exp_t => TermBase.exp_t, e2: TermBase.exp_t) => - switch (e2.term) { + (cont: TermBase.exp_t => TermBase.exp_t, e: TermBase.exp_t) => + switch (e.term) { | Parens(e) => cont(e) - | _ => cont(e2) + | _ => cont(e) }, ~f_pat= - (cont, e2) => - switch (e2.term) { + (cont, e) => + switch (e.term) { | Parens(e) => cont(e) - | _ => cont(e2) + | _ => cont(e) }, ~f_typ= - (cont, e2) => - switch (e2.term) { + (cont, e) => + switch (e.term) { | Parens(e) => cont(e) - | _ => cont(e2) + | _ => cont(e) }, _, ); @@ -563,7 +563,7 @@ let tests = [ "-num*1", ), menhir_maketerm_equivalent_test("Concatenation association", "1::2::3::[]"), - menhir_doesnt_crash_test( + menhir_maketerm_equivalent_test( "Altered Documentation Buffer: Basic Reference", {| let empty_hole = ? in @@ -646,7 +646,7 @@ let poly_id: (forall a -> (a -> a)) = (typfun a -> (fun (x : a) -> x)) in let apply_both: -forall a -> forall b -> (forall c -> (c -> c)) -> ((a, b) -> (a, b)) = +forall a -> forall b -> (forall c -> c -> c) -> ((a, b) -> (a, b)) = typfun a -> typfun b -> fun (f : forall c -> (c -> c)) -> fun ((x, y) : (a, b)) -> (f@(x), f@(y)) From 7929bccb4ccd5290167e00b9b781de5bcdd7eea9 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 16:25:59 -0500 Subject: [PATCH 123/281] Add tests for polymorphism documentation buffer --- test/Test_Menhir.re | 45 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 42 insertions(+), 3 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index d73779b007..282fe1f7e6 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -61,7 +61,8 @@ let skip_parser_test = (name: string, _exp: Term.Exp.t, _actual: string) => test_case(name, `Quick, () => {Alcotest.skip()}); let skip_menhir_only_test = (name: string, _exp: Term.Exp.t, _actual: string) => test_case(name, `Quick, () => {Alcotest.skip()}); - +let skip_menhir_maketerm_equivalent_test = (name: string, _actual: string) => + test_case(name, `Quick, () => {Alcotest.skip()}); // TODO Assert against result instead of exception for parse failure for better error messages let parser_test = (name: string, exp: Term.Exp.t, actual: string) => test_case( @@ -563,6 +564,10 @@ let tests = [ "-num*1", ), menhir_maketerm_equivalent_test("Concatenation association", "1::2::3::[]"), + skip_menhir_maketerm_equivalent_test( + "and less than precedence", + "true && 23 < int_of_float(51.00)" // TODO This looks like a bug in MakeTerm + ), menhir_maketerm_equivalent_test( "Altered Documentation Buffer: Basic Reference", {| @@ -666,7 +671,9 @@ test 2 + 2 == 5 end; 2 + 2 |}, ), - menhir_doesnt_crash_test( + // TODO This is an issue with `int_of_float` being parsed + // as a builtin function in menhir and a Var in MakeTerm + skip_menhir_maketerm_equivalent_test( "Altered Documentation Buffer: Projectors", {| let fold = (((((((((((()))))))))))) in @@ -682,7 +689,7 @@ let ____ = "shift" in let _____ = "malicious" in let ______ = "a shift malicious" in let box: Int = "malicious" in -if true && 23 < int_of_float(51.00) +if true && (23 < int_of_float(51.00)) then ______ else "its: " ++ box |}, ), menhir_doesnt_crash_test( @@ -801,4 +808,36 @@ test result_equal( Ok(Lam("bro", Var("bro")))) end |}, ), + menhir_maketerm_equivalent_test( + "Altered Documentation Buffer: Polymorphism", + {| +let id = typfun A -> (fun (x : A) -> x) in +let ex1 = id@(1) in +let const : forall A -> (forall B -> (A -> B -> A)) = +typfun A -> (typfun B -> (fun x -> fun y -> x)) in +let ex2 = const@@(2)("Hello World") in +let apply_both : forall A -> forall B -> (forall D -> D -> D) -> (A , B) -> (A , B) = +typfun A -> typfun B -> fun f -> fun (x, y) -> (f@(x), f@(y)) in +let ex3 = apply_both@@(id)(3, "Hello World") in +let emptylist : forall A -> [A] = typfun A -> [] in +let map : forall A -> forall B -> (A -> B) -> ([A] -> [B]) = + typfun A -> typfun B -> fun f : (A -> B) -> fun l : [A] -> + case l + | h :: t => f(h) :: map@@(f)(t) + | _ => emptylist@ +end in +let ex4 = map@@(string_of_int)([1,2,3]) in +type MyList = rec A -> (Nil + Cons(Int, A)) in +let x : MyList = Cons(1, Cons(2, Cons(3, Nil))) in +type MyList2 = Nil + Cons(Int, MyList2) in +type Broken = Int -> (HasInt(Int) + HasMore(Int, Broken)) in +let list_of_mylist : (MyList -> [Int]) = fun myl : MyList -> + case myl + | Nil => [] + | Cons(h, t) => h :: list_of_mylist(t) +end in +let ex5 = list_of_mylist(x) in +(ex1, ex2, ex3, ex4, ex5) + |}, + ), ]; From dbdc10852f6b08b9c552e05f940cbd579302a2bc Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 13 Dec 2024 16:56:09 -0500 Subject: [PATCH 124/281] Temporary fix for some failing tests on builtins --- test/Test_Menhir.re | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 282fe1f7e6..ccddb10898 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -21,6 +21,16 @@ let strip_parens = (cont: TermBase.exp_t => TermBase.exp_t, e: TermBase.exp_t) => switch (e.term) { | Parens(e) => cont(e) + | Var(x) => + let builtin = + VarMap.lookup(Haz3lcore.Builtins.Pervasives.builtins, x); + cont( + switch (builtin) { + | Some(Fn(_, _, _)) => cont(BuiltinFun(x) |> Exp.fresh) // TODO Decide whether these should be builtins in the parser or vars + | Some(Const(_, _)) + | None => cont(e) + }, + ); | _ => cont(e) }, ~f_pat= @@ -564,9 +574,9 @@ let tests = [ "-num*1", ), menhir_maketerm_equivalent_test("Concatenation association", "1::2::3::[]"), - skip_menhir_maketerm_equivalent_test( + menhir_maketerm_equivalent_test( "and less than precedence", - "true && 23 < int_of_float(51.00)" // TODO This looks like a bug in MakeTerm + "true && (23 < int_of_float(51.00))" // TODO This looks like a bug in MakeTerm ), menhir_maketerm_equivalent_test( "Altered Documentation Buffer: Basic Reference", @@ -673,7 +683,7 @@ test 2 + 2 == 5 end; ), // TODO This is an issue with `int_of_float` being parsed // as a builtin function in menhir and a Var in MakeTerm - skip_menhir_maketerm_equivalent_test( + menhir_maketerm_equivalent_test( "Altered Documentation Buffer: Projectors", {| let fold = (((((((((((()))))))))))) in @@ -808,7 +818,7 @@ test result_equal( Ok(Lam("bro", Var("bro")))) end |}, ), - menhir_maketerm_equivalent_test( + skip_menhir_maketerm_equivalent_test( "Altered Documentation Buffer: Polymorphism", {| let id = typfun A -> (fun (x : A) -> x) in From 1465aa5ee699746c69eaaa67ac4a6578c57acef8 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sat, 14 Dec 2024 12:10:07 -0500 Subject: [PATCH 125/281] Add todo about literal t in t_typ --- src/haz3lmenhir/Lexer.mll | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index c2df65649d..b2f2359039 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -122,7 +122,7 @@ rule token = | "type" {TYP} | "$" {DOLLAR_SIGN} | "~" {TILDE} - | "t" {T_TYP} + | "t" {T_TYP} (* TODO These make it very easy to get an unparseable program *) | "p" {P_PAT} | "tp" {TP_TPAT} | "e" {E_EXP} From a7aa7330b652ae14fea43c15d90d606cbc68c94f Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sat, 14 Dec 2024 12:31:15 -0500 Subject: [PATCH 126/281] Add rec type --- src/haz3lmenhir/AST.re | 3 ++- src/haz3lmenhir/Conversion.re | 1 + src/haz3lmenhir/Lexer.mll | 1 + src/haz3lmenhir/Parser.mly | 7 ++++--- 4 files changed, 8 insertions(+), 4 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index d2d3979063..ad165002de 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -96,7 +96,8 @@ type typ = | ArrowType(typ, typ) | TypVar(string) | InvalidTyp(string) - | ForallType(tpat, typ); + | ForallType(tpat, typ) + | RecType(tpat, typ); [@deriving (show({with_path: false}), sexp)] type pat = diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 233af093a2..d77141a4a8 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -261,6 +261,7 @@ and Typ: { Sum(converted_terms); | SumTerm(_) => raise(Failure("SumTerm conversion not possible")) | ForallType(tp, t) => Forall(TPat.of_menhir_ast(tp), of_menhir_ast(t)) + | RecType(tp, t) => Rec(TPat.of_menhir_ast(tp), of_menhir_ast(t)) }; } and constructormap_of_sumterm_list = diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index b2f2359039..7735bcf84f 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -128,6 +128,7 @@ rule token = | "e" {E_EXP} | "named_fun" {NAMED_FUN} | "forall" {FORALL} + | "rec" {REC} | identifier as i { IDENT(i) } | constructor_ident as i { CONSTRUCTOR_IDENT(i)} | eof { EOF } diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 6a47c98ef9..b845a04b61 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -13,6 +13,7 @@ open AST %token TILDE %token NAMED_FUN %token FORALL +%token REC %token UNDEF %token SEXP_STRING %token DOLLAR_SIGN @@ -138,14 +139,13 @@ open AST %left OPEN_CURLY -(* %left COMMA *) -%left AT_SYMBOL %left IN %left DOLLAR_SIGN %left L_NOT L_AND L_OR -(* Other *) %right CONS +%left AT_SYMBOL + %left OPEN_PAREN %left QUESTION %left TILDE @@ -239,6 +239,7 @@ typ: | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } | t1 = typ; DASH_ARROW; t2 = typ { ArrowType(t1, t2) } | s = sumTyp; { s } + | REC; c=tpat; DASH_ARROW; t = typ { RecType(c, t) } nonAscriptingPat: | OPEN_PAREN; p = pat; CLOSE_PAREN { p } From 9e997a321807ae565626b82dd9840fb43b37059d Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sat, 14 Dec 2024 12:33:13 -0500 Subject: [PATCH 127/281] Polymorphism buffer parsing --- test/Test_Menhir.re | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index ccddb10898..8f63be6261 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -818,10 +818,10 @@ test result_equal( Ok(Lam("bro", Var("bro")))) end |}, ), - skip_menhir_maketerm_equivalent_test( + menhir_maketerm_equivalent_test( + // Variable names are renamed due to lexing overtaking e, t, p, and tp "Altered Documentation Buffer: Polymorphism", - {| -let id = typfun A -> (fun (x : A) -> x) in + {|let id = typfun A -> (fun (x : A) -> x) in let ex1 = id@(1) in let const : forall A -> (forall B -> (A -> B -> A)) = typfun A -> (typfun B -> (fun x -> fun y -> x)) in @@ -831,20 +831,20 @@ typfun A -> typfun B -> fun f -> fun (x, y) -> (f@(x), f@(y)) in let ex3 = apply_both@@(id)(3, "Hello World") in let emptylist : forall A -> [A] = typfun A -> [] in let map : forall A -> forall B -> (A -> B) -> ([A] -> [B]) = - typfun A -> typfun B -> fun f : (A -> B) -> fun l : [A] -> + typfun A -> typfun B -> fun (f : (A -> B)) -> fun (l : [A]) -> case l - | h :: t => f(h) :: map@@(f)(t) + | (h :: a) => f(h) :: map@@(f)(a) | _ => emptylist@ end in let ex4 = map@@(string_of_int)([1,2,3]) in -type MyList = rec A -> (Nil + Cons(Int, A)) in +type MyList = rec A -> (+Nil + Cons(Int, A)) in let x : MyList = Cons(1, Cons(2, Cons(3, Nil))) in -type MyList2 = Nil + Cons(Int, MyList2) in -type Broken = Int -> (HasInt(Int) + HasMore(Int, Broken)) in -let list_of_mylist : (MyList -> [Int]) = fun myl : MyList -> +type MyList2 = +Nil + Cons(Int, MyList2) in +type Broken = Int -> (+HasInt(Int) + HasMore(Int, Broken)) in +let list_of_mylist : (MyList -> [Int]) = fun (myl : MyList) -> case myl | Nil => [] - | Cons(h, t) => h :: list_of_mylist(t) + | Cons((h, a)) => h :: list_of_mylist(a) end in let ex5 = list_of_mylist(x) in (ex1, ex2, ex3, ex4, ex5) From 978e65ead1ed3eb125d4c695e7dd4e20f32be9d4 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sat, 14 Dec 2024 14:50:31 -0500 Subject: [PATCH 128/281] Fix precedence between less than and && --- src/haz3lmenhir/Parser.mly | 2 +- test/Test_Menhir.re | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index b845a04b61..8fee6b3abe 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -118,6 +118,7 @@ open AST %left COLON %right DASH_ARROW +%left L_NOT L_AND L_OR // TODO Check with Milan. I moved this to make tests pass. (* Int op precedences *) %left DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL @@ -141,7 +142,6 @@ open AST %left IN %left DOLLAR_SIGN -%left L_NOT L_AND L_OR %right CONS %left AT_SYMBOL diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 8f63be6261..0dc1717bd2 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -576,7 +576,7 @@ let tests = [ menhir_maketerm_equivalent_test("Concatenation association", "1::2::3::[]"), menhir_maketerm_equivalent_test( "and less than precedence", - "true && (23 < int_of_float(51.00))" // TODO This looks like a bug in MakeTerm + "true && 23 < int_of_float(51.00)" // TODO This looks like a bug in MakeTerm ), menhir_maketerm_equivalent_test( "Altered Documentation Buffer: Basic Reference", From 5ecdfc6060f3d4f4184f4e683e423f04bed51010 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sat, 14 Dec 2024 15:04:07 -0500 Subject: [PATCH 129/281] Tighten assertions on tests --- test/Test_Menhir.re | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 0dc1717bd2..359d8ee281 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -702,7 +702,7 @@ let box: Int = "malicious" in if true && (23 < int_of_float(51.00)) then ______ else "its: " ++ box |}, ), - menhir_doesnt_crash_test( + menhir_maketerm_equivalent_test( "Altered Documentation Buffer: Types & Static Errors", {| let _ = unbound in @@ -750,7 +750,7 @@ let _: [Int] = 1::[2.0] in "BYE" |}, ), - menhir_doesnt_crash_test( + menhir_maketerm_equivalent_test( "Altered Documentation Buffer: adt dynamics", {| type Exp = From d7423f15ab33d6bac607e42a1d3f607903af8136 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sat, 14 Dec 2024 16:12:58 -0500 Subject: [PATCH 130/281] Start reverse conversion --- src/haz3lmenhir/AST.re | 1 + src/haz3lmenhir/Conversion.re | 202 ++++++++++++++++++++++++++++++++++ 2 files changed, 203 insertions(+) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index ad165002de..d8798ded94 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -45,6 +45,7 @@ type op_bin_string = | Concat | Equals; +// TODO Rename to match others [@deriving (show({with_path: false}), sexp)] type binOp = | IntOp(op_bin_int) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index d77141a4a8..0d0399189b 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -9,6 +9,15 @@ module FilterAction = { | Hide => (Eval, One) }; }; + + let of_core = (a: t): AST.filter_action => { + switch (a) { + | (Eval, All) => Eval + | (Step, One) => Pause + | (Step, All) => Debug + | (Eval, One) => Hide + }; + }; }; module Operators = { @@ -40,6 +49,80 @@ module Operators = { }; }; + let of_core_op_bin = (op: op_bin): AST.binOp => { + switch (op) { + | Int(op_int) => + IntOp( + switch (op_int) { + | Plus => Plus + | Minus => Minus + | Times => Times + | Power => Power + | Divide => Divide + | LessThan => LessThan + | LessThanOrEqual => LessThanOrEqual + | GreaterThan => GreaterThan + | GreaterThanOrEqual => GreaterThanOrEqual + | Equals => Equals + | NotEquals => NotEquals + }, + ) + | Float(op_float) => + FloatOp( + switch (op_float) { + | Plus => Plus + | Minus => Minus + | Times => Times + | Power => Power + | Divide => Divide + | LessThan => LessThan + | LessThanOrEqual => LessThanOrEqual + | GreaterThan => GreaterThan + | GreaterThanOrEqual => GreaterThanOrEqual + | Equals => Equals + | NotEquals => NotEquals + }, + ) + | Bool(op_bool) => + BoolOp( + switch (op_bool) { + | And => And + | Or => Or + }, + ) + | String(op_string) => + StringOp( + switch (op_string) { + | Concat => Concat + | Equals => Equals + }, + ) + }; + }; + + let of_core_op_un = (op: op_un): AST.op_un => { + switch (op) { + | Meta(meta) => + Meta( + switch (meta) { + | Unquote => Unquote + }, + ) + | Int(i) => + Int( + switch (i) { + | Minus => Minus + }, + ) + | Bool(b) => + Bool( + switch (b) { + | Not => Not + }, + ) + }; + }; + [@deriving (show({with_path: false}), sexp, yojson)] let float_op_of_menhir_ast = (op: AST.op_bin_float): op_bin_float => { switch (op) { @@ -104,6 +187,7 @@ module Operators = { module rec Exp: { let term_of_menhir_ast: AST.exp => Haz3lcore.Exp.term; let of_menhir_ast: AST.exp => Haz3lcore.Exp.t; + let of_core: Haz3lcore.Exp.t => AST.exp; } = { let rec term_of_menhir_ast = (exp: AST.exp): Haz3lcore.Exp.term => { switch (exp) { @@ -212,6 +296,64 @@ module rec Exp: { and of_menhir_ast = (exp: AST.exp): Haz3lcore.Exp.t => { Haz3lcore.IdTagged.fresh(term_of_menhir_ast(exp)); }; + + let rec of_core = (exp: Haz3lcore.Exp.t): AST.exp => { + switch (exp.term) { + | Invalid(_) => InvalidExp("Invalid") + | Int(i) => Int(i) + | Float(f) => Float(f) + | String(s) => String(s) + | Bool(b) => Bool(b) + | Var(x) => Var(x) + | Deferral(InAp) => Deferral + | ListLit(l) => ListExp(List.map(of_core, l)) + | Tuple(l) => TupleExp(List.map(of_core, l)) + | Let(p, e1, e2) => Let(Pat.of_core(p), of_core(e1), of_core(e2)) + | FixF(p, e, _) => FixF(Pat.of_core(p), of_core(e)) + | TypFun(tp, e, _) => TypFun(TPat.of_core(tp), of_core(e)) + | Undefined => Undefined + | TyAlias(tp, ty, e) => + TyAlias(TPat.of_core(tp), Typ.of_core(ty), of_core(e)) + | BuiltinFun(s) => BuiltinFun(s) + | Ap(Forward, e1, e2) => ApExp(of_core(e1), TupleExp([of_core(e2)])) + | BinOp(op, e1, e2) => + BinExp(of_core(e1), Operators.of_core_op_bin(op), of_core(e2)) + | If(e1, e2, e3) => If(of_core(e1), of_core(e2), of_core(e3)) + | Match(e, l) => + CaseExp( + of_core(e), + List.map(((p, e)) => (Pat.of_core(p), of_core(e)), l), + ) + | Cast(e, t1, t2) => + Cast(of_core(e), Typ.of_core(t1), Typ.of_core(t2)) + | FailedCast(e, t1, t2) => + FailedCast(of_core(e), Typ.of_core(t1), Typ.of_core(t2)) + | EmptyHole => EmptyHole + | Seq(e1, e2) => Seq(of_core(e1), of_core(e2)) + | Test(e) => Test(of_core(e)) + | Cons(e1, e2) => Cons(of_core(e1), of_core(e2)) + | ListConcat(e1, e2) => ListConcat(of_core(e1), of_core(e2)) + | Filter(Filter({pat, act}), body) => + Filter(FilterAction.of_core(act), of_core(pat), of_core(body)) + | TypAp(e, ty) => TypAp(of_core(e), Typ.of_core(ty)) + | UnOp(op, e) => UnOp(Operators.of_core_op_un(op), of_core(e)) + | DynamicErrorHole(e, s) => + DynamicErrorHole( + of_core(e), + Sexplib.Sexp.to_string(Haz3lcore.InvalidOperationError.sexp_of_t(s)), + ) + | Deferral(_) => Deferral + | Filter(_) => raise(Failure("Filter not supported")) // TODO + | MultiHole(_) => raise(Failure("MultiHole not supported")) // TODO + | Closure(_) => raise(Failure("Closure not supported")) // TODO + | Parens(e) => of_core(e) + | Constructor(s, typ) => Constructor(s, Typ.of_core(typ)) + | DeferredAp(e, es) => + ApExp(of_core(e), TupleExp(List.map(of_core, es))) + | Fun(p, e, _, name_opt) => Fun(Pat.of_core(p), of_core(e), name_opt) + | Ap(Reverse, _, _) => raise(Failure("Reverse not supported")) // TODO + }; + }; } and Typ: { let of_menhir_ast: AST.typ => Haz3lcore.Typ.t; @@ -220,6 +362,7 @@ and Typ: { let constructormap_variant_of_sumterm: AST.typ => Haz3lcore.ConstructorMap.variant(Haz3lcore.Typ.t); + let of_core: Haz3lcore.Typ.t => AST.typ; } = { let rec of_menhir_ast = (typ: AST.typ): Haz3lcore.Typ.t => { Haz3lcore.IdTagged.fresh(term_of_menhir_ast(typ)); @@ -299,10 +442,38 @@ and Typ: { ) }; }; + let of_core_type_provenance = + (p: Haz3lcore.TermBase.type_provenance): AST.typ_provenance => { + switch (p) { + | Internal => Internal + | Hole(EmptyHole) => EmptyHole + | _ => raise(Failure("Unknown type_provenance")) + }; + }; + let rec of_core = (typ: Haz3lcore.Typ.t): AST.typ => { + switch (typ.term) { + | Int => IntType + | Float => FloatType + | String => StringType + | Bool => BoolType + | Var(x) => TypVar(x) + | Prod([]) => UnitType + | Prod(ts) => TupleType(List.map(of_core, ts)) + | List(t) => ArrayType(of_core(t)) + | Arrow(t1, t2) => ArrowType(of_core(t1), of_core(t2)) + | Unknown(p) => UnknownType(of_core_type_provenance(p)) + | Forall(tp, t) => ForallType(TPat.of_core(tp), of_core(t)) + | Rec(tp, t) => RecType(TPat.of_core(tp), of_core(t)) + | Parens(t) => of_core(t) + | Ap(_) => raise(Failure("Ap not supported")) // TODO + | Sum(_) => raise(Failure("Sum not supported")) // TODO + }; + }; } and TPat: { let of_menhir_ast: AST.tpat => Haz3lcore.TPat.t; let term_of_menhir_ast: AST.tpat => Haz3lcore.TPat.term; + let of_core: Haz3lcore.TPat.t => AST.tpat; } = { let rec term_of_menhir_ast = (tpat: AST.tpat): Haz3lcore.TPat.term => { switch (tpat) { @@ -314,10 +485,20 @@ and TPat: { and of_menhir_ast = (tpat: AST.tpat) => { Haz3lcore.IdTagged.fresh(term_of_menhir_ast(tpat)); }; + + let of_core = (tpat: Haz3lcore.TPat.t): AST.tpat => { + switch (tpat.term) { + | EmptyHole => EmptyHoleTPat + | Var(x) => VarTPat(x) + | Invalid(i) => InvalidTPat(i) + | MultiHole(_) => raise(Failure("MultiHole not supported")) // TODO + }; + }; } and Pat: { let term_of_menhir_ast: AST.pat => Haz3lcore.Pat.term; let of_menhir_ast: AST.pat => Haz3lcore.Pat.t; + let of_core: Haz3lcore.Pat.t => AST.pat; } = { let rec term_of_menhir_ast = (pat: AST.pat): Haz3lcore.Pat.term => { switch (pat) { @@ -341,4 +522,25 @@ and Pat: { and of_menhir_ast = (pat: AST.pat): Haz3lcore.Pat.t => { Haz3lcore.IdTagged.fresh(term_of_menhir_ast(pat)); }; + let rec of_core = (pat: Haz3lcore.Pat.t): AST.pat => { + switch (pat.term) { + | Invalid(_) => InvalidPat("Invalid") + | Int(i) => IntPat(i) + | Float(f) => FloatPat(f) + | Var(x) => VarPat(x) + | Constructor(x, ty) => ConstructorPat(x, Typ.of_core(ty)) + | String(s) => StringPat(s) + | Tuple(l) => TuplePat(List.map(of_core, l)) + | Bool(b) => BoolPat(b) + | Cons(p1, p2) => ConsPat(of_core(p1), of_core(p2)) + | ListLit(l) => ListPat(List.map(of_core, l)) + | Ap(p1, p2) => ApPat(of_core(p1), of_core(p2)) + | EmptyHole => EmptyHolePat + | Wild => WildPat + | MultiHole(_) => raise(Failure("MultiHole not supported")) // TODO + | Cast(p, t1, t2) => + CastPat(of_core(p), Typ.of_core(t1), Typ.of_core(t2)) + | Parens(p) => of_core(p) + }; + }; }; From a860c6a8b06b2f822c0221bebe6b6d6774a7c496 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 15 Dec 2024 12:16:57 -0500 Subject: [PATCH 131/281] Fix ExpToSegment float serialization --- src/haz3lcore/pretty/ExpToSegment.re | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index c2f57d0229..0cf8180f54 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -166,7 +166,7 @@ let rec exp_to_pretty = (~settings: Settings.t, exp: Exp.t): pretty => { | Int(n) => text_to_pretty(exp |> Exp.rep_id, Sort.Exp, Int.to_string(n)) // TODO: do floats print right? | Float(f) => - text_to_pretty(exp |> Exp.rep_id, Sort.Exp, Float.to_string(f)) + text_to_pretty(exp |> Exp.rep_id, Sort.Exp, Printf.sprintf("%f", f)) | String(s) => text_to_pretty(exp |> Exp.rep_id, Sort.Exp, "\"" ++ s ++ "\"") // TODO: Make sure types are correct @@ -475,7 +475,7 @@ and pat_to_pretty = (~settings: Settings.t, pat: Pat.t): pretty => { | Var(v) => text_to_pretty(pat |> Pat.rep_id, Sort.Pat, v) | Int(n) => text_to_pretty(pat |> Pat.rep_id, Sort.Pat, Int.to_string(n)) | Float(f) => - text_to_pretty(pat |> Pat.rep_id, Sort.Pat, Float.to_string(f)) + text_to_pretty(pat |> Pat.rep_id, Sort.Pat, Printf.sprintf("%f", f)) | Bool(b) => text_to_pretty(pat |> Pat.rep_id, Sort.Pat, Bool.to_string(b)) | String(s) => text_to_pretty(pat |> Pat.rep_id, Sort.Pat, "\"" ++ s ++ "\"") From 4e5379cce6692659ac0412278710611131380844 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 15 Dec 2024 12:17:29 -0500 Subject: [PATCH 132/281] Stop negative floats and ints --- src/haz3lmenhir/Lexer.mll | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index 7735bcf84f..c1c7cb2b1a 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -18,9 +18,10 @@ let parse_float_string s = | Failure _ -> print_endline ("Parse Float String Lexing Error On: " ^ s); 0.0 } - -let float = '-'? ['0'-'9']* '.' ['0'-'9']* -let int = '-'? ['0'-'9'] ['0'-'9']* +(* TODO We don't yet support negative floats in MakeTerm *) +let float = ['0'-'9']* '.' ['0'-'9']* +(* negative ints are done through unop *) +let int = ['0'-'9'] ['0'-'9']* let string = '"' ([^ '"' '\\'] | '\\' ['"' '\\'])* '"' From 8c3b7536ea13c4bec1bc8952fcb7823d90c2bc22 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 15 Dec 2024 12:18:00 -0500 Subject: [PATCH 133/281] Start using qcheck to test parser --- dune-project | 5 +++- hazel.opam | 4 +++ hazel.opam.locked | 10 +++++-- src/haz3lmenhir/AST.re | 59 ++++++++++++++++++++++++++++++------------ src/haz3lmenhir/dune | 9 +++++-- test/Test_Menhir.re | 32 +++++++++++++++++++++++ 6 files changed, 97 insertions(+), 22 deletions(-) diff --git a/dune-project b/dune-project index 4dd3442bc4..a8e9d11527 100644 --- a/dune-project +++ b/dune-project @@ -40,6 +40,9 @@ unionFind ocamlformat (junit_alcotest :with-test) - ocaml-lsp-server)) ; After upgrading to opam 2.2 use with-dev https://opam.ocaml.org/blog/opam-2-2-0/ + ocaml-lsp-server + qcheck + qcheck-alcotest + ppx_deriving_qcheck)) ; After upgrading to opam 2.2 use with-dev https://opam.ocaml.org/blog/opam-2-2-0/ ; See the complete stanza docs at https://dune.readthedocs.io/en/stable/reference/dune-project/index.html diff --git a/hazel.opam b/hazel.opam index 09ee887ab3..16ed5457ba 100644 --- a/hazel.opam +++ b/hazel.opam @@ -14,6 +14,7 @@ depends: [ "reason" {>= "3.12.0"} "ppx_yojson_conv_lib" "ppx_yojson_conv" + "incr_dom" "bisect_ppx" "omd" {>= "2.0.0~alpha4"} "ezjs_idb" @@ -25,6 +26,9 @@ depends: [ "ocamlformat" "junit_alcotest" {with-test} "ocaml-lsp-server" + "qcheck" + "qcheck-alcotest" + "ppx_deriving_qcheck" "odoc" {with-doc} ] build: [ diff --git a/hazel.opam.locked b/hazel.opam.locked index 856b83ad33..399042a839 100644 --- a/hazel.opam.locked +++ b/hazel.opam.locked @@ -10,7 +10,7 @@ homepage: "https://github.com/hazelgrove/hazel" bug-reports: "https://github.com/hazelgrove/hazel/issues" depends: [ "abstract_algebra" {= "v0.16.0"} - "alcotest" {= "1.8.0" & with-test} + "alcotest" {= "1.8.0"} "angstrom" {= "0.16.1"} "astring" {= "0.8.5"} "async" {= "v0.16.0"} @@ -38,8 +38,8 @@ depends: [ "bignum" {= "v0.16.0"} "bigstringaf" {= "0.10.0"} "bin_prot" {= "v0.16.0"} - "bonsai" {= "v0.16.0"} "bisect_ppx" {= "2.8.3"} + "bonsai" {= "v0.16.0"} "camlp-streams" {= "5.0.1"} "chrome-trace" {= "3.16.0"} "cmdliner" {= "1.3.0"} @@ -142,6 +142,7 @@ depends: [ "omd" {= "2.0.0~alpha4"} "ordering" {= "3.16.0"} "ordinal_abbreviation" {= "v0.16.0"} + "ounit2" {= "2.2.7"} "parsexp" {= "v0.16.0"} "patdiff" {= "v0.16.1"} "patience_diff" {= "v0.16.0"} @@ -157,6 +158,7 @@ depends: [ "ppx_custom_printf" {= "v0.16.0"} "ppx_derivers" {= "1.2.1"} "ppx_deriving" {= "6.0.2"} + "ppx_deriving_qcheck" {= "0.5"} "ppx_disable_unused_warnings" {= "v0.16.0"} "ppx_enumerate" {= "v0.16.0"} "ppx_expect" {= "v0.16.0"} @@ -193,6 +195,10 @@ depends: [ "protocol_version_header" {= "v0.16.0"} "ptime" {= "1.2.0" & with-test} "ptmap" {= "2.0.5"} + "qcheck" {= "0.23"} + "qcheck-alcotest" {= "0.23"} + "qcheck-core" {= "0.23"} + "qcheck-ounit" {= "0.23"} "re" {= "1.12.0"} "reason" {= "3.12.0"} "record_builder" {= "v0.16.0"} diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index d8798ded94..625e027659 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -1,13 +1,13 @@ open Sexplib.Std; -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type filter_action = | Pause | Debug | Hide | Eval; -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type op_bin_float = | Plus | Minus @@ -21,12 +21,12 @@ type op_bin_float = | Equals | NotEquals; -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type op_bin_bool = | And | Or; -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type op_bin_int = | Plus | Minus @@ -40,49 +40,49 @@ type op_bin_int = | Equals | NotEquals; -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type op_bin_string = | Concat | Equals; // TODO Rename to match others -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type binOp = | IntOp(op_bin_int) | FloatOp(op_bin_float) | StringOp(op_bin_string) | BoolOp(op_bin_bool); -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type op_un_meta = | Unquote; -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type op_un_int = | Minus; -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type op_un_bool = | Not; -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type op_un = | Meta(op_un_meta) | Int(op_un_int) | Bool(op_un_bool); -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type typ_provenance = | Internal | EmptyHole; -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type tpat = - | InvalidTPat(string) + | InvalidTPat([@arb small_printable_gen] string) | EmptyHoleTPat | VarTPat(string); -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type typ = | IntType | StringType @@ -100,7 +100,7 @@ type typ = | ForallType(tpat, typ) | RecType(tpat, typ); -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type pat = | CastPat(pat, typ, typ) | EmptyHolePat @@ -117,12 +117,12 @@ type pat = | ApPat(pat, pat) | InvalidPat(string); -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type if_consistency = | Consistent | Inconsistent; -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, qcheck)] type deferral_pos = | InAp | OutsideAp; @@ -161,3 +161,28 @@ type exp = | TypAp(exp, typ) | DynamicErrorHole(exp, string) | TyAlias(tpat, typ, exp); + +let arb_int = QCheck.(map(x => Int(x), small_int)); + +let arb_str = + QCheck.(map(x => String(x), string_small_of(Gen.char_range('a', 'z')))); // Make strings anything other than `"`" + +// Floats are positive because we use UnOp minus +let arb_float = QCheck.(map(x => Float(x), pos_float)); + +// ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* +// Can't be t, e, tp, or p because of the lexer +let arb_ident = + QCheck.( + let arb_alpha = Gen.char_range('a', 'd'); // TODO make this support full indent instead of just lower alpha + string_gen_of_size(Gen.int_range(1, 5), arb_alpha) + ); + +let arb_var = QCheck.(map(x => Var(x), arb_ident)); + +let arb_exp_sized = (size: int): QCheck.arbitrary(exp) => { + open QCheck; + let i = QCheck.small_int; + let foo = arb_typ_sized; + oneof([arb_int, arb_str, arb_float, arb_var]); +}; diff --git a/src/haz3lmenhir/dune b/src/haz3lmenhir/dune index d9a9683a19..1169266987 100644 --- a/src/haz3lmenhir/dune +++ b/src/haz3lmenhir/dune @@ -1,11 +1,16 @@ (library (name haz3lmenhir) - (libraries util re sexplib unionFind haz3lcore) + (libraries util re sexplib unionFind haz3lcore qcheck-alcotest) (modules AST Conversion Interface Lexer Parser) (instrumentation (backend bisect_ppx)) (preprocess - (pps ppx_let ppx_sexp_conv ppx_deriving.show ppx_yojson_conv))) + (pps + ppx_let + ppx_sexp_conv + ppx_deriving.show + ppx_yojson_conv + ppx_deriving_qcheck))) (ocamllex Lexer) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 359d8ee281..2f57753d86 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -241,6 +241,37 @@ let menhir_doesnt_crash_test = (name, src) => }, ); +let i = ref(0); + +let qcheck_menhir_maketerm_equivalent_test = + QCheck.Test.make( + ~name="Menhir and maketerm are equivalent", + ~count=1000, + AST.arb_exp_sized(1), + exp => { + let core_exp = Conversion.Exp.of_menhir_ast(exp); + + let segment = + ExpToSegment.exp_to_segment( + ~settings= + ExpToSegment.Settings.of_core( + ~inline=true, // TODO What does inline do? + CoreSettings.off, + ), + core_exp, + ); + + let serialized = Printer.of_segment(~holes=Some("?"), segment); + let make_term_parsed = make_term_parse(serialized); + let menhir_parsed = + Haz3lmenhir.Conversion.Exp.of_menhir_ast( + Haz3lmenhir.Interface.parse_program(serialized), + ); + + Haz3lcore.DHExp.fast_equal(make_term_parsed, menhir_parsed); + }, + ); + let tests = [ parser_test("Integer Literal", Int(8) |> Exp.fresh, "8"), parser_test("Fun", fun_exp, "fun x -> x"), @@ -850,4 +881,5 @@ let ex5 = list_of_mylist(x) in (ex1, ex2, ex3, ex4, ex5) |}, ), + QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), ]; From 542f10f19ead712f7bdc8461c2d59c9426b869ff Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 15 Dec 2024 13:15:51 -0500 Subject: [PATCH 134/281] Add lists to pbt for menhir --- src/haz3lmenhir/AST.re | 49 ++++++++++++++++++++++++++++++++++++------ test/Test_Menhir.re | 14 ++++++++---- 2 files changed, 53 insertions(+), 10 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 625e027659..22ce3771c6 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -180,9 +180,46 @@ let arb_ident = let arb_var = QCheck.(map(x => Var(x), arb_ident)); -let arb_exp_sized = (size: int): QCheck.arbitrary(exp) => { - open QCheck; - let i = QCheck.small_int; - let foo = arb_typ_sized; - oneof([arb_int, arb_str, arb_float, arb_var]); -}; +let arb_exp_sized: QCheck.arbitrary(exp) = + QCheck.( + let leaf = oneof([arb_int, arb_str, arb_float, arb_var]); + + let gen: Gen.t(exp) = + QCheck.Gen.sized_size( + QCheck.Gen.int_range(0, 10), // Currently only size 10 + QCheck.Gen.fix((self, n) => { + switch (n) { + | 0 => leaf.gen + | _ => + print_endline("Size: " ++ string_of_int(n)); + let list_sizes = + if (n <= 1) { + // Bug in nat_split for size=0 + Gen.pure([|0, 0, 0, 0, 0|]); + } else { + QCheck.Gen.nat_split( + ~size=n - 1, + 5 // Make different size lists + ); + }; + let lists_gen = + Gen.map( + (sizes: array(int)) => { + let sizes = Array.to_list(sizes); + let exps = List.map((size: int) => self(size), sizes); + let flattened = Gen.flatten_l(exps); + let foo = + Gen.map((exps: list(exp)) => ListExp(exps), flattened); + foo; + }, + list_sizes, + ); + let foo = Gen.join(lists_gen); + + Gen.oneof([leaf.gen, foo]); + } + }), + ); + + QCheck.make(gen) + ); // TODO Printers, shrinkers stuff diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 2f57753d86..68e3ce54bb 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -88,8 +88,9 @@ let parser_test = (name: string, exp: Term.Exp.t, actual: string) => }, ); -let menhir_maketerm_equivalent_test = (name: string, actual: string) => - test_case(name, `Quick, () => { +let menhir_maketerm_equivalent_test = + (~speed_level=`Quick, name: string, actual: string) => + test_case(name, speed_level, () => { alco_check( "Menhir parse matches MakeTerm parse", make_term_parse(actual), @@ -246,8 +247,8 @@ let i = ref(0); let qcheck_menhir_maketerm_equivalent_test = QCheck.Test.make( ~name="Menhir and maketerm are equivalent", - ~count=1000, - AST.arb_exp_sized(1), + ~count=100, + AST.arb_exp_sized, exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); @@ -610,6 +611,7 @@ let tests = [ "true && 23 < int_of_float(51.00)" // TODO This looks like a bug in MakeTerm ), menhir_maketerm_equivalent_test( + ~speed_level=`Slow, "Altered Documentation Buffer: Basic Reference", {| let empty_hole = ? in @@ -715,6 +717,7 @@ test 2 + 2 == 5 end; // TODO This is an issue with `int_of_float` being parsed // as a builtin function in menhir and a Var in MakeTerm menhir_maketerm_equivalent_test( + ~speed_level=`Slow, "Altered Documentation Buffer: Projectors", {| let fold = (((((((((((()))))))))))) in @@ -734,6 +737,7 @@ if true && (23 < int_of_float(51.00)) then ______ else "its: " ++ box |}, ), menhir_maketerm_equivalent_test( + ~speed_level=`Slow, "Altered Documentation Buffer: Types & Static Errors", {| let _ = unbound in @@ -782,6 +786,7 @@ let _: [Int] = 1::[2.0] in |}, ), menhir_maketerm_equivalent_test( + ~speed_level=`Slow, "Altered Documentation Buffer: adt dynamics", {| type Exp = @@ -851,6 +856,7 @@ Ok(Lam("bro", Var("bro")))) end ), menhir_maketerm_equivalent_test( // Variable names are renamed due to lexing overtaking e, t, p, and tp + ~speed_level=`Slow, "Altered Documentation Buffer: Polymorphism", {|let id = typfun A -> (fun (x : A) -> x) in let ex1 = id@(1) in From ee3b6bf6f6768183731c39832786a423a818f680 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 15 Dec 2024 13:23:41 -0500 Subject: [PATCH 135/281] Start tuple generator - ExpToSegment doesn't add parens for tuples which menhir requires so test fails --- src/haz3lmenhir/AST.re | 49 +++++++++++++++++++++++++++--------------- test/Test_Menhir.re | 5 +++-- 2 files changed, 35 insertions(+), 19 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 22ce3771c6..ea2520ab90 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -191,7 +191,6 @@ let arb_exp_sized: QCheck.arbitrary(exp) = switch (n) { | 0 => leaf.gen | _ => - print_endline("Size: " ++ string_of_int(n)); let list_sizes = if (n <= 1) { // Bug in nat_split for size=0 @@ -202,24 +201,40 @@ let arb_exp_sized: QCheck.arbitrary(exp) = 5 // Make different size lists ); }; - let lists_gen = - Gen.map( - (sizes: array(int)) => { - let sizes = Array.to_list(sizes); - let exps = List.map((size: int) => self(size), sizes); - let flattened = Gen.flatten_l(exps); - let foo = - Gen.map((exps: list(exp)) => ListExp(exps), flattened); - foo; - }, - list_sizes, - ); - let foo = Gen.join(lists_gen); - - Gen.oneof([leaf.gen, foo]); + + Gen.oneof([ + leaf.gen, + Gen.join( + Gen.map( + (sizes: array(int)) => { + let exps = Array.map((size: int) => self(size), sizes); + let flattened = Gen.flatten_a(exps); + Gen.map( + (exps: array(exp)) => ListExp(Array.to_list(exps)), + flattened, + ); + }, + list_sizes, + ), + ), + // Need to make ExpToSegment add parens for tuples for menhir + // Gen.join( + // Gen.map( + // (sizes: array(int)) => { + // let exps = Array.map((size: int) => self(size), sizes); + // let flattened = Gen.flatten_a(exps); + // Gen.map( + // (exps: array(exp)) => TupleExp(Array.to_list(exps)), + // flattened, + // ); + // }, + // list_sizes, + // ), + // ), + ]); } }), ); - QCheck.make(gen) + QCheck.make(~print=show_exp, gen) ); // TODO Printers, shrinkers stuff diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 68e3ce54bb..c5746e068b 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -71,8 +71,9 @@ let skip_parser_test = (name: string, _exp: Term.Exp.t, _actual: string) => test_case(name, `Quick, () => {Alcotest.skip()}); let skip_menhir_only_test = (name: string, _exp: Term.Exp.t, _actual: string) => test_case(name, `Quick, () => {Alcotest.skip()}); -let skip_menhir_maketerm_equivalent_test = (name: string, _actual: string) => - test_case(name, `Quick, () => {Alcotest.skip()}); +let skip_menhir_maketerm_equivalent_test = + (~speed_level=`Quick, name: string, _actual: string) => + test_case(name, speed_level, () => {Alcotest.skip()}); // TODO Assert against result instead of exception for parse failure for better error messages let parser_test = (name: string, exp: Term.Exp.t, actual: string) => test_case( From f90e1463b528351fcb8d4c1b25938d02ac5a23e1 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 15 Dec 2024 15:06:25 -0500 Subject: [PATCH 136/281] Fix tuple generator --- src/haz3lmenhir/AST.re | 26 +++++++++++++------------- test/Test_Menhir.re | 17 +++++++++++++++++ 2 files changed, 30 insertions(+), 13 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index ea2520ab90..e35d7187df 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -218,19 +218,19 @@ let arb_exp_sized: QCheck.arbitrary(exp) = ), ), // Need to make ExpToSegment add parens for tuples for menhir - // Gen.join( - // Gen.map( - // (sizes: array(int)) => { - // let exps = Array.map((size: int) => self(size), sizes); - // let flattened = Gen.flatten_a(exps); - // Gen.map( - // (exps: array(exp)) => TupleExp(Array.to_list(exps)), - // flattened, - // ); - // }, - // list_sizes, - // ), - // ), + Gen.join( + Gen.map( + (sizes: array(int)) => { + let exps = Array.map((size: int) => self(size), sizes); + let flattened = Gen.flatten_a(exps); + Gen.map( + (exps: array(exp)) => TupleExp(Array.to_list(exps)), + flattened, + ); + }, + list_sizes, + ), + ), ]); } }), diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index c5746e068b..2da8481ade 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -253,6 +253,22 @@ let qcheck_menhir_maketerm_equivalent_test = exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); + // TODO Maybe only do this when necessary. + // TODO Check with Matthew if I'm using this correctly + // Add parens around tuples + let core_exp = + Exp.map_term( + ~f_exp= + (cont, e) => + switch (e.term) { + | Tuple(es) => + Parens(Tuple(es |> List.map(cont)) |> Exp.fresh) + |> Exp.fresh + | _ => cont(e) + }, + core_exp, + ); + let segment = ExpToSegment.exp_to_segment( ~settings= @@ -264,6 +280,7 @@ let qcheck_menhir_maketerm_equivalent_test = ); let serialized = Printer.of_segment(~holes=Some("?"), segment); + print_endline("Serialized: " ++ serialized); let make_term_parsed = make_term_parse(serialized); let menhir_parsed = Haz3lmenhir.Conversion.Exp.of_menhir_ast( From f988005da808417c5aaeaa8127f251d795fbd419 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 15 Dec 2024 15:08:26 -0500 Subject: [PATCH 137/281] Reduce size of generator to speed up test --- src/haz3lmenhir/AST.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index e35d7187df..aff75b41ac 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -186,7 +186,7 @@ let arb_exp_sized: QCheck.arbitrary(exp) = let gen: Gen.t(exp) = QCheck.Gen.sized_size( - QCheck.Gen.int_range(0, 10), // Currently only size 10 + QCheck.Gen.int_range(0, 5), // Currently only size 10 QCheck.Gen.fix((self, n) => { switch (n) { | 0 => leaf.gen From 91476cb9cf4992ffc4bf5578679d713199ed0829 Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sun, 15 Dec 2024 17:44:11 -0500 Subject: [PATCH 138/281] Fixed the shift/reduce error with new fun exps --- src/haz3lmenhir/Parser.mly | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 8fee6b3abe..26a6157c37 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -146,7 +146,7 @@ open AST %right CONS %left AT_SYMBOL -%left OPEN_PAREN +%left OPEN_PAREN CLOSE_PAREN %left QUESTION %left TILDE %nonassoc UMINUS /* Unary minus (prefix) */ From d13e07ce55246c2ac293be5f175945cd7e1a0bca Mon Sep 17 00:00:00 2001 From: Milan Lustig Date: Sun, 15 Dec 2024 17:49:14 -0500 Subject: [PATCH 139/281] Fixed the single character invalid form annotations in the menhir parser --- src/haz3lmenhir/Lexer.mll | 8 ++++---- src/haz3lmenhir/Parser.mly | 8 ++++---- test/Test_Elaboration.re | 2 +- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index c1c7cb2b1a..5bcc4270b8 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -123,10 +123,10 @@ rule token = | "type" {TYP} | "$" {DOLLAR_SIGN} | "~" {TILDE} - | "t" {T_TYP} (* TODO These make it very easy to get an unparseable program *) - | "p" {P_PAT} - | "tp" {TP_TPAT} - | "e" {E_EXP} + | "?t" {T_TYP} (* TODO These make it very easy to get an unparseable program *) + | "?p" {P_PAT} + | "?tp" {TP_TPAT} + | "?e" {E_EXP} | "named_fun" {NAMED_FUN} | "forall" {FORALL} | "rec" {REC} diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 26a6157c37..7112b06b1c 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -226,7 +226,7 @@ sumTyp: typ: | c = CONSTRUCTOR_IDENT { TypVar(c) } | c = IDENT { TypVar(c) } - | QUESTION; T_TYP; s = STRING { InvalidTyp(s) } + | T_TYP; s = STRING { InvalidTyp(s) } | INT_TYPE { IntType } | FLOAT_TYPE { FloatType } | BOOL_TYPE { BoolType } @@ -244,7 +244,7 @@ typ: nonAscriptingPat: | OPEN_PAREN; p = pat; CLOSE_PAREN { p } | OPEN_PAREN; p = pat; COMMA; pats = separated_list(COMMA, pat); CLOSE_PAREN { TuplePat(p :: pats) } - | QUESTION; P_PAT; s = STRING { InvalidPat(s) } + | P_PAT; s = STRING { InvalidPat(s) } | WILD { WildPat } | QUESTION { EmptyHolePat } | OPEN_SQUARE_BRACKET; l = separated_list(COMMA, pat); CLOSE_SQUARE_BRACKET; { ListPat(l) } @@ -290,7 +290,7 @@ filterAction: | EVAL { Eval } tpat: - | QUESTION; TP_TPAT; s = STRING {InvalidTPat(s)} + | TP_TPAT; s = STRING {InvalidTPat(s)} | QUESTION {EmptyHoleTPat} | v = IDENT {VarTPat v} | v = CONSTRUCTOR_IDENT {VarTPat v} @@ -332,7 +332,7 @@ exp: | e1 = exp; AT_SYMBOL; e2 = exp { ListConcat(e1, e2) } | e1 = exp; CONS; e2 = exp { Cons(e1, e2) } | e1 = exp; SEMI_COLON; e2 = exp { Seq(e1, e2) } - | QUESTION; E_EXP; s = STRING; { InvalidExp(s) } + | E_EXP; s = STRING; { InvalidExp(s) } | WILD {Deferral} | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index c50146e882..406c913d34 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -673,7 +673,7 @@ undef alco_check_menhir("List exp (menhir)", list_exp_str, list_exp_uexp); let invalid_str = " -? e \"x\" +?e \"x\" "; let invalid_uexp: Exp.t = Invalid("x") |> Exp.fresh; let invalid_menhir = () => From 92b9d5d8e1ef403082261ee6575c93e81c0a7235 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 16 Dec 2024 08:29:50 -0500 Subject: [PATCH 140/281] Make AST sum type closer to Haz3lcore --- src/haz3lmenhir/AST.re | 9 +++-- src/haz3lmenhir/Conversion.re | 68 +++++++---------------------------- 2 files changed, 18 insertions(+), 59 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index aff75b41ac..5657f37fb2 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -89,8 +89,7 @@ type typ = | FloatType | BoolType | UnitType - | SumTyp(typ, option(typ)) - | SumTerm(string, option(typ)) + | SumTyp(sumtype) | UnknownType(typ_provenance) | TupleType(list(typ)) | ArrayType(typ) @@ -98,7 +97,11 @@ type typ = | TypVar(string) | InvalidTyp(string) | ForallType(tpat, typ) - | RecType(tpat, typ); + | RecType(tpat, typ) +and sumterm = + | Variant(string, option(typ)) + | BadEntry(typ) +and sumtype = list(sumterm); [@deriving (show({with_path: false}), sexp, qcheck)] type pat = diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 0d0399189b..7c46130626 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -357,11 +357,7 @@ module rec Exp: { } and Typ: { let of_menhir_ast: AST.typ => Haz3lcore.Typ.t; - let constructormap_of_sumterm_list: - list(AST.typ) => Haz3lcore.ConstructorMap.t(Haz3lcore.Typ.t); - let constructormap_variant_of_sumterm: - AST.typ => Haz3lcore.ConstructorMap.variant(Haz3lcore.Typ.t); let of_core: Haz3lcore.Typ.t => AST.typ; } = { let rec of_menhir_ast = (typ: AST.typ): Haz3lcore.Typ.t => { @@ -385,62 +381,22 @@ and Typ: { | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) | ArrayType(t) => List(of_menhir_ast(t)) | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) - | SumTyp(term, next) => - let terms = ref([term]); - let rec go = (next: option(AST.typ)): list(AST.typ) => { - switch (next) { - | Some(t) => - switch (t) { - | SumTyp(term, next) => - terms := [term, ...terms^]; - go(next); - | _ => raise(Failure("SumTyp conversion failure")) - } - | None => terms^ - }; - }; - let _ = go(next); - let converted_terms = constructormap_of_sumterm_list(terms^); + | SumTyp(sumterms) => + open Haz3lcore; + let converted_terms: list(ConstructorMap.variant(TermBase.typ_t)) = + List.map( + (sumterm: AST.sumterm): ConstructorMap.variant(TermBase.typ_t) => + switch (sumterm) { + | Variant(name, typ) => + Variant(name, [], Option.map(of_menhir_ast, typ)) + | BadEntry(typ) => BadEntry(of_menhir_ast(typ)) + }, + sumterms, + ); Sum(converted_terms); - | SumTerm(_) => raise(Failure("SumTerm conversion not possible")) | ForallType(tp, t) => Forall(TPat.of_menhir_ast(tp), of_menhir_ast(t)) | RecType(tp, t) => Rec(TPat.of_menhir_ast(tp), of_menhir_ast(t)) }; - } - and constructormap_of_sumterm_list = - (terms: list(AST.typ)): Haz3lcore.ConstructorMap.t(Haz3lcore.Typ.t) => { - List.map(constructormap_variant_of_sumterm, terms) |> List.rev; - } - and constructormap_variant_of_sumterm = - (term: AST.typ): Haz3lcore.ConstructorMap.variant(Haz3lcore.Typ.t) => { - switch (term) { - | SumTerm(name, typs) => - switch (typs) { - | Some(typs) => - switch (typs) { - | TupleType(ts) => - switch (List.length(ts)) { - | 1 => Variant(name, [], Some(of_menhir_ast(List.hd(ts)))) - | _ => Variant(name, [], Some(of_menhir_ast(typs))) - } - | _ => - raise( - Failure( - "TupleType expected in constructormap_variant_of_sumterm but not found", - ), - ) - } - | None => Variant(name, [], None) - } - | UnknownType(EmptyHole) => - BadEntry(Unknown(Hole(EmptyHole)) |> Haz3lcore.Typ.fresh) // TODO Figure out if this is correct - | _ => - raise( - Failure( - "SumTerm expected in constructormap_variant_of_sumterm but not found", - ), - ) - }; }; let of_core_type_provenance = (p: Haz3lcore.TermBase.type_provenance): AST.typ_provenance => { From 36307a9f58b12d8771731f3e94507fb9668f2a4c Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 16 Dec 2024 08:30:18 -0500 Subject: [PATCH 141/281] Forgot to commit parser --- src/haz3lmenhir/Parser.mly | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 7112b06b1c..4c8348b184 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -156,6 +156,7 @@ open AST %left STRING_CONCAT STRING_EQUAL %type exp +%type sumTyp %start program @@ -214,14 +215,15 @@ binExp: %inline sumTerm: - | i = CONSTRUCTOR_IDENT; t = tupleType { SumTerm(i, Some(t)) } - | i = CONSTRUCTOR_IDENT { SumTerm(i, None) } - | QUESTION { UnknownType(EmptyHole) } + | i = CONSTRUCTOR_IDENT; t = tupleType { Variant(i, Some(t)) } + | i = CONSTRUCTOR_IDENT { Variant(i, None) } + | QUESTION { BadEntry(UnknownType(EmptyHole)) } + // We don't support sum types without the leading plus in the parser syntax sumTyp: - | PLUS; s = sumTerm; { SumTyp(s, None) } %prec SUM_TYP - | PLUS; s = sumTerm; t = sumTyp { SumTyp(s, Some(t)) } + | PLUS; s = sumTerm; { [s] } %prec SUM_TYP + | PLUS; s = sumTerm; t = sumTyp { [s] @ t } typ: | c = CONSTRUCTOR_IDENT { TypVar(c) } @@ -238,7 +240,7 @@ typ: | t = tupleType { t } | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } | t1 = typ; DASH_ARROW; t2 = typ { ArrowType(t1, t2) } - | s = sumTyp; { s } + | s = sumTyp; { SumTyp(s) } | REC; c=tpat; DASH_ARROW; t = typ { RecType(c, t) } nonAscriptingPat: From bef0026695a7dc82ce4c590463a155e3318ea2b5 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 16 Dec 2024 08:33:47 -0500 Subject: [PATCH 142/281] Change AST generator ident to use full a-z --- src/haz3lmenhir/AST.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 5657f37fb2..7248eb11b3 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -177,7 +177,7 @@ let arb_float = QCheck.(map(x => Float(x), pos_float)); // Can't be t, e, tp, or p because of the lexer let arb_ident = QCheck.( - let arb_alpha = Gen.char_range('a', 'd'); // TODO make this support full indent instead of just lower alpha + let arb_alpha = Gen.char_range('a', 'z'); // TODO make this support full indent instead of just lower alpha string_gen_of_size(Gen.int_range(1, 5), arb_alpha) ); From e2f5f7212c46829053a5289d8da835dedd2ab4e7 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 16 Dec 2024 08:55:06 -0500 Subject: [PATCH 143/281] Add some more leaf generators --- src/haz3lmenhir/AST.re | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 7248eb11b3..f02c9ced72 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -185,7 +185,16 @@ let arb_var = QCheck.(map(x => Var(x), arb_ident)); let arb_exp_sized: QCheck.arbitrary(exp) = QCheck.( - let leaf = oneof([arb_int, arb_str, arb_float, arb_var]); + let leaf = + oneof([ + arb_int, + arb_str, + arb_float, + arb_var, + always(~print=show_exp, EmptyHole), + // always(~print=show_exp, TupleExp([])), // TODO Seems to be broken + always(~print=show_exp, ListExp([])), + ]); let gen: Gen.t(exp) = QCheck.Gen.sized_size( @@ -220,20 +229,20 @@ let arb_exp_sized: QCheck.arbitrary(exp) = list_sizes, ), ), - // Need to make ExpToSegment add parens for tuples for menhir Gen.join( Gen.map( (sizes: array(int)) => { let exps = Array.map((size: int) => self(size), sizes); let flattened = Gen.flatten_a(exps); Gen.map( - (exps: array(exp)) => TupleExp(Array.to_list(exps)), + (exps: array(exp)) => TupleExp(Array.to_list(exps)), // TODO See if there's a way to do unit and various sizes here flattened, ); }, list_sizes, ), ), + Gen.map(exp => Test(exp), self(n - 1)), ]); } }), From 8288d7a646dad7a4266a94babc50131f27e390d5 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 16 Dec 2024 14:01:08 -0500 Subject: [PATCH 144/281] Reenable unit generation --- src/haz3lmenhir/AST.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index f02c9ced72..4e1ee6a2fc 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -192,7 +192,7 @@ let arb_exp_sized: QCheck.arbitrary(exp) = arb_float, arb_var, always(~print=show_exp, EmptyHole), - // always(~print=show_exp, TupleExp([])), // TODO Seems to be broken + always(~print=show_exp, TupleExp([])), always(~print=show_exp, ListExp([])), ]); From c77d065a315e202d2cf99097547fc34ffd3c1b1d Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 16 Dec 2024 15:14:37 -0500 Subject: [PATCH 145/281] Add constructors to generator and exclude keywords --- src/haz3lmenhir/AST.re | 62 +++++++++++++++++++++++++++++------ src/haz3lmenhir/Conversion.re | 3 +- test/Test_Menhir.re | 13 ++++---- 3 files changed, 60 insertions(+), 18 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 4e1ee6a2fc..71f909ab8e 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -172,18 +172,45 @@ let arb_str = // Floats are positive because we use UnOp minus let arb_float = QCheck.(map(x => Float(x), pos_float)); +let arb_lower_alpha = QCheck.Gen.char_range('a', 'z'); + +let arb_constructor_ident = + QCheck. + // TODO handle full constructor ident including nums + ( + let leading = Gen.char_range('A', 'Z'); + let tail = string_gen_of_size(Gen.int_range(1, 4), arb_lower_alpha); + make( + ~print=t => t, + Gen.map2((l, t) => String.make(1, l) ++ t, leading, tail.gen), + ) + ); // ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* -// Can't be t, e, tp, or p because of the lexer let arb_ident = QCheck.( - let arb_alpha = Gen.char_range('a', 'z'); // TODO make this support full indent instead of just lower alpha - string_gen_of_size(Gen.int_range(1, 5), arb_alpha) + // TODO make this support full indent instead of just lower alpha + QCheck.map( + ident => + // if ident is a keyword add a suffix + switch (ident) { + | "let" + | "if" + | "pause" + | "debug" + | "hide" + | "eval" + | "rec" + | "in" => ident ++ "2" + | _ => ident + }, + string_gen_of_size(Gen.int_range(1, 5), arb_lower_alpha), + ) ); let arb_var = QCheck.(map(x => Var(x), arb_ident)); -let arb_exp_sized: QCheck.arbitrary(exp) = +let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => QCheck.( let leaf = oneof([ @@ -197,9 +224,8 @@ let arb_exp_sized: QCheck.arbitrary(exp) = ]); let gen: Gen.t(exp) = - QCheck.Gen.sized_size( - QCheck.Gen.int_range(0, 5), // Currently only size 10 - QCheck.Gen.fix((self, n) => { + QCheck.Gen.fix( + (self: int => Gen.t(exp), n) => { switch (n) { | 0 => leaf.gen | _ => @@ -243,10 +269,26 @@ let arb_exp_sized: QCheck.arbitrary(exp) = ), ), Gen.map(exp => Test(exp), self(n - 1)), + Gen.map2( + (name, typ) => { + print_endline("Generating constructor"); + Constructor(name, typ); + }, + arb_ident.gen, // Replace with constructor type + gen_typ_sized(n - 1), + ), ]); } - }), + }, + n, ); - QCheck.make(~print=show_exp, gen) - ); // TODO Printers, shrinkers stuff + gen + ) +and gen_typ_sized = (n: int): QCheck.Gen.t(typ) => QCheck.Gen.pure(IntType); +// TODO Printers, shrinkers stuff + +let gen_exp = QCheck.Gen.sized(gen_exp_sized); +let gen_typ = QCheck.Gen.sized(gen_typ_sized); + +let arb_exp = QCheck.make(~print=show_exp, gen_exp); diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 7c46130626..6461085da8 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -347,7 +347,8 @@ module rec Exp: { | MultiHole(_) => raise(Failure("MultiHole not supported")) // TODO | Closure(_) => raise(Failure("Closure not supported")) // TODO | Parens(e) => of_core(e) - | Constructor(s, typ) => Constructor(s, Typ.of_core(typ)) + | Constructor(s, typ) => + Constructor(s, Typ.of_core(typ)); | DeferredAp(e, es) => ApExp(of_core(e), TupleExp(List.map(of_core, es))) | Fun(p, e, _, name_opt) => Fun(Pat.of_core(p), of_core(e), name_opt) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 2da8481ade..27224295ea 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -249,7 +249,7 @@ let qcheck_menhir_maketerm_equivalent_test = QCheck.Test.make( ~name="Menhir and maketerm are equivalent", ~count=100, - AST.arb_exp_sized, + QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(3)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); @@ -280,14 +280,13 @@ let qcheck_menhir_maketerm_equivalent_test = ); let serialized = Printer.of_segment(~holes=Some("?"), segment); - print_endline("Serialized: " ++ serialized); let make_term_parsed = make_term_parse(serialized); - let menhir_parsed = - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(serialized), - ); + let menhir_parsed = Haz3lmenhir.Interface.parse_program(serialized); + let menhir_parsed_converted = + Haz3lmenhir.Conversion.Exp.of_menhir_ast(menhir_parsed); - Haz3lcore.DHExp.fast_equal(make_term_parsed, menhir_parsed); + Haz3lcore.DHExp.fast_equal(make_term_parsed, menhir_parsed_converted); + // && menhir_parsed == exp; // TODO Add this as separate property }, ); From 3d11a0d5f00f35b25b6b0bc2ba6e3d0413581516 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 16 Dec 2024 15:15:28 -0500 Subject: [PATCH 146/281] Formatting --- src/haz3lmenhir/Conversion.re | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 6461085da8..7c46130626 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -347,8 +347,7 @@ module rec Exp: { | MultiHole(_) => raise(Failure("MultiHole not supported")) // TODO | Closure(_) => raise(Failure("Closure not supported")) // TODO | Parens(e) => of_core(e) - | Constructor(s, typ) => - Constructor(s, Typ.of_core(typ)); + | Constructor(s, typ) => Constructor(s, Typ.of_core(typ)) | DeferredAp(e, es) => ApExp(of_core(e), TupleExp(List.map(of_core, es))) | Fun(p, e, _, name_opt) => Fun(Pat.of_core(p), of_core(e), name_opt) From 428faaa0db5404cd1c8dbf7235c0b95a3489e6e6 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 16 Dec 2024 15:21:41 -0500 Subject: [PATCH 147/281] Fix constructor ident - Add stubbed test for menhir/exptosegment invertibility --- src/haz3lmenhir/AST.re | 7 ++----- test/Test_Menhir.re | 47 +++++++++++++++++++++++++++++++++++++++++- 2 files changed, 48 insertions(+), 6 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 71f909ab8e..182271930c 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -270,11 +270,8 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => ), Gen.map(exp => Test(exp), self(n - 1)), Gen.map2( - (name, typ) => { - print_endline("Generating constructor"); - Constructor(name, typ); - }, - arb_ident.gen, // Replace with constructor type + (name, typ) => {Constructor(name, typ)}, + arb_constructor_ident.gen, gen_typ_sized(n - 1), ), ]); diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 27224295ea..e3d030ea97 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -286,7 +286,51 @@ let qcheck_menhir_maketerm_equivalent_test = Haz3lmenhir.Conversion.Exp.of_menhir_ast(menhir_parsed); Haz3lcore.DHExp.fast_equal(make_term_parsed, menhir_parsed_converted); - // && menhir_parsed == exp; // TODO Add this as separate property + }, + ); + +// TODO This fails due to types not being serialized on constructors +// We should do a pass before the equality check that removes the types on the constructors and check equality after +let qcheck_menhir_serialized_equivalent_test = + QCheck.Test.make( + ~name="Menhir through ExpToSegment and back", + ~count=100, + QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(3)), + exp => { + let core_exp = Conversion.Exp.of_menhir_ast(exp); + + // TODO Maybe only do this when necessary. + // TODO Check with Matthew if I'm using this correctly + // Add parens around tuples + let core_exp = + Exp.map_term( + ~f_exp= + (cont, e) => + switch (e.term) { + | Tuple(es) => + Parens(Tuple(es |> List.map(cont)) |> Exp.fresh) + |> Exp.fresh + | _ => cont(e) + }, + core_exp, + ); + + let segment = + ExpToSegment.exp_to_segment( + ~settings= + ExpToSegment.Settings.of_core( + ~inline=true, // TODO What does inline do? + CoreSettings.off, + ), + core_exp, + ); + + let serialized = Printer.of_segment(~holes=Some("?"), segment); + let menhir_parsed = Haz3lmenhir.Interface.parse_program(serialized); + print_endline("Serialized: " ++ serialized); + print_endline("Menhir parsed: " ++ AST.show_exp(menhir_parsed)); + print_endline("Original" ++ AST.show_exp(exp)); + menhir_parsed == exp; }, ); @@ -905,4 +949,5 @@ let ex5 = list_of_mylist(x) in |}, ), QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), + // QCheck_alcotest.to_alcotest(qcheck_menhir_serialized_equivalent_test), ]; From 956fb32ea28a52b1791bf4944251372417f6d55b Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Mon, 16 Dec 2024 18:50:32 -0500 Subject: [PATCH 148/281] Several operator precedence improvements as well as a generator for binary expressions --- src/haz3lmenhir/AST.re | 6 ++++++ src/haz3lmenhir/Parser.mly | 17 ++++++----------- test/Test_Menhir.re | 6 ++++++ 3 files changed, 18 insertions(+), 11 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 182271930c..cffa202f75 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -274,6 +274,12 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => arb_constructor_ident.gen, gen_typ_sized(n - 1), ), + Gen.map3( + (op, e1, e2) => BinExp(e1, op, e2), + gen_binOp, + self((n - 1) / 2), + self((n - 1) / 2), + ), ]); } }, diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 4c8348b184..f7d2030ba0 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -118,21 +118,17 @@ open AST %left COLON %right DASH_ARROW -%left L_NOT L_AND L_OR // TODO Check with Milan. I moved this to make tests pass. +%right L_OR // TODO Check with Milan. I moved this to make tests pass. +%right L_AND +%right L_NOT -(* Int op precedences *) -%left DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL + +%left GREATER_THAN LESS_THAN DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT DOUBLE_EQUAL_FLOAT STRING_EQUAL +%right STRING_CONCAT %left PLUS MINUS %left DIVIDE TIMES %right POWER -%left GREATER_THAN LESS_THAN - -(* End of int op precedences *) - -(* Float op precedences *) - -%left DOUBLE_EQUAL_FLOAT NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT %left PLUS_FLOAT MINUS_FLOAT %left TIMES_FLOAT DIVIDE_FLOAT @@ -153,7 +149,6 @@ open AST -%left STRING_CONCAT STRING_EQUAL %type exp %type sumTyp diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index e3d030ea97..dc2f72ec76 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -280,11 +280,17 @@ let qcheck_menhir_maketerm_equivalent_test = ); let serialized = Printer.of_segment(~holes=Some("?"), segment); + print_endline("Serialized: " ++ serialized); let make_term_parsed = make_term_parse(serialized); let menhir_parsed = Haz3lmenhir.Interface.parse_program(serialized); let menhir_parsed_converted = Haz3lmenhir.Conversion.Exp.of_menhir_ast(menhir_parsed); + print_endline("MakeTerm: " ++ DHExp.show(make_term_parsed)); + print_endline( + "Menhir parsed: " ++ DHExp.show(menhir_parsed_converted), + ); + Haz3lcore.DHExp.fast_equal(make_term_parsed, menhir_parsed_converted); }, ); From 39f2999bdef799b0088a4956e42b4b62c4583470 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 17 Dec 2024 10:39:13 -0500 Subject: [PATCH 149/281] Increase quickcheck test size to help find bugs --- test/Test_Menhir.re | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index dc2f72ec76..5f54299757 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -248,8 +248,8 @@ let i = ref(0); let qcheck_menhir_maketerm_equivalent_test = QCheck.Test.make( ~name="Menhir and maketerm are equivalent", - ~count=100, - QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(3)), + ~count=1000, + QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(4)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); @@ -301,7 +301,7 @@ let qcheck_menhir_serialized_equivalent_test = QCheck.Test.make( ~name="Menhir through ExpToSegment and back", ~count=100, - QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(3)), + QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(4)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); From ca2a0c03f7e3488534b64f32f3e318ebb7694141 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 17 Dec 2024 15:54:30 -0500 Subject: [PATCH 150/281] Update String concat precedence to match Precedence.re --- src/haz3lcore/lang/Form.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lcore/lang/Form.re b/src/haz3lcore/lang/Form.re index 5ab6368cc8..fe936143be 100644 --- a/src/haz3lcore/lang/Form.re +++ b/src/haz3lcore/lang/Form.re @@ -256,7 +256,7 @@ let forms: list((string, t)) = [ ("divide", mk_infix("/", Exp, P.mult)), ("equals", mk_infix("==", Exp, P.eqs)), ("string_equals", mk_infix("$==", Exp, P.eqs)), - ("string_concat", mk_infix("++", Exp, P.plus)), + ("string_concat", mk_infix("++", Exp, P.concat)), ("lt", mk_infix("<", Exp, P.eqs)), ("gt", mk_infix(">", Exp, P.eqs)), ("not_equals", mk_infix("!=", Exp, P.eqs)), From 5b2f3cf36effb95bafdad7f31b3ba7fd0da6e0cc Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 17 Dec 2024 16:08:04 -0500 Subject: [PATCH 151/281] Remove keywords from arb_constructor_ident --- src/haz3lmenhir/AST.re | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index cffa202f75..c779b042de 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -180,9 +180,22 @@ let arb_constructor_ident = ( let leading = Gen.char_range('A', 'Z'); let tail = string_gen_of_size(Gen.int_range(1, 4), arb_lower_alpha); - make( - ~print=t => t, - Gen.map2((l, t) => String.make(1, l) ++ t, leading, tail.gen), + QCheck.map( + ident => + // if ident is a keyword add a suffix + switch (ident) { + | "Int" + | "Float" + | "String" + | "Unknown" + | "Internal" + | "Bool" => ident ++ "2" + | _ => ident + }, + make( + ~print=t => t, + Gen.map2((l, t) => String.make(1, l) ++ t, leading, tail.gen), + ), ) ); @@ -280,6 +293,12 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => self((n - 1) / 2), self((n - 1) / 2), ), + Gen.map3( + (e1, e2, e3) => If(e1, e2, e3), + self((n - 1) / 3), + self((n - 1) / 3), + self((n - 1) / 3), + ), ]); } }, From ff0b3250a9a95b638d1b90554c06d10b774fbf81 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 17 Dec 2024 16:14:45 -0500 Subject: [PATCH 152/281] More generators --- src/haz3lmenhir/AST.re | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index c779b042de..7eb8dca3be 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -189,7 +189,7 @@ let arb_constructor_ident = | "String" | "Unknown" | "Internal" - | "Bool" => ident ++ "2" + | "Bool" => "keyword" | _ => ident }, make( @@ -214,7 +214,7 @@ let arb_ident = | "hide" | "eval" | "rec" - | "in" => ident ++ "2" + | "in" => "keyword" | _ => ident }, string_gen_of_size(Gen.int_range(1, 5), arb_lower_alpha), @@ -299,6 +299,12 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => self((n - 1) / 3), self((n - 1) / 3), ), + Gen.map3( + (p, e1, e2) => Let(p, e1, e2), + gen_pat_sized((n - 1) / 3), + self((n - 1) / 3), + self((n - 1) / 3), + ), ]); } }, @@ -307,7 +313,8 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => gen ) -and gen_typ_sized = (n: int): QCheck.Gen.t(typ) => QCheck.Gen.pure(IntType); +and gen_typ_sized = (_n: int): QCheck.Gen.t(typ) => QCheck.Gen.pure(IntType) +and gen_pat_sized = (_n: int): QCheck.Gen.t(pat) => QCheck.Gen.pure(WildPat); // TODO Printers, shrinkers stuff let gen_exp = QCheck.Gen.sized(gen_exp_sized); From a96659c7f01f2e7794ebb2f93f9bea6cb55143fd Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 17 Dec 2024 16:18:34 -0500 Subject: [PATCH 153/281] Fix precedences --- src/haz3lmenhir/Parser.mly | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index f7d2030ba0..8de7077ffd 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -124,15 +124,9 @@ open AST %left GREATER_THAN LESS_THAN DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT DOUBLE_EQUAL_FLOAT STRING_EQUAL -%right STRING_CONCAT -%left PLUS MINUS -%left DIVIDE TIMES -%right POWER - - -%left PLUS_FLOAT MINUS_FLOAT -%left TIMES_FLOAT DIVIDE_FLOAT -%right POWER_FLOAT +%right STRING_CONCAT +%left DIVIDE TIMES TIMES_FLOAT DIVIDE_FLOAT +%right POWER POWER_FLOAT %left OPEN_CURLY From 4cd1e56efd5af0cff73a79bc28654e89cd05370f Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 17 Dec 2024 16:20:16 -0500 Subject: [PATCH 154/281] revert mistake --- src/haz3lmenhir/Parser.mly | 1 + 1 file changed, 1 insertion(+) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 8de7077ffd..f9247562e2 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -125,6 +125,7 @@ open AST %left GREATER_THAN LESS_THAN DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT DOUBLE_EQUAL_FLOAT STRING_EQUAL %right STRING_CONCAT +%left PLUS MINUS PLUS_FLOAT MINUS_FLOAT %left DIVIDE TIMES TIMES_FLOAT DIVIDE_FLOAT %right POWER POWER_FLOAT From e7af810a1ec0a825171e7ebbcf63a44e31ff99f8 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 17 Dec 2024 16:29:43 -0500 Subject: [PATCH 155/281] More generators for types --- src/haz3lmenhir/AST.re | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 7eb8dca3be..7c9e97c39a 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -293,6 +293,7 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => self((n - 1) / 2), self((n - 1) / 2), ), + // Gen.map2((op, e) => UnOp(op, e), gen_op_un, self(n - 1)), // TODO ExpToSegment broken for UnOp Gen.map3( (e1, e2, e3) => If(e1, e2, e3), self((n - 1) / 3), @@ -313,8 +314,17 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => gen ) -and gen_typ_sized = (_n: int): QCheck.Gen.t(typ) => QCheck.Gen.pure(IntType) -and gen_pat_sized = (_n: int): QCheck.Gen.t(pat) => QCheck.Gen.pure(WildPat); +and gen_typ_sized = (_n: int): QCheck.Gen.t(typ) => + QCheck.Gen.( + oneof([ + return(StringType), + return(FloatType), + return(BoolType), + return(UnitType), + ]) + ) +and gen_pat_sized = (_n: int): QCheck.Gen.t(pat) => + QCheck.Gen.pure(WildPat); // TODO Printers, shrinkers stuff let gen_exp = QCheck.Gen.sized(gen_exp_sized); From b1da56a3e2260e0af4adb062675966ed8a569fca Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Wed, 18 Dec 2024 11:03:08 -0500 Subject: [PATCH 156/281] Generate product types --- src/haz3lmenhir/AST.re | 49 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 42 insertions(+), 7 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 7c9e97c39a..72ebcc2d40 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -314,14 +314,49 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => gen ) -and gen_typ_sized = (_n: int): QCheck.Gen.t(typ) => +and gen_typ_sized = QCheck.Gen.( - oneof([ - return(StringType), - return(FloatType), - return(BoolType), - return(UnitType), - ]) + let leaf_nodes = + oneof([ + return(StringType), + return(FloatType), + return(BoolType), + return(UnitType), + ]); + fix((self, n) => + switch (n) { + | 0 => leaf_nodes + | _ => + let list_sizes = + if (n <= 1) { + // Bug in nat_split for size=0 + pure([|0, 0, 0, 0, 0|]); + } else { + QCheck.Gen.nat_split( + ~size=n - 1, + 5 // Make different size lists + ); + }; + + oneof([ + leaf_nodes, + join( + map( + (sizes: array(int)) => { + let typs = Array.map((size: int) => self(size), sizes); + + let flattened = flatten_a(typs); + map( + (typs: array(typ)) => TupleType(Array.to_list(typs)), + flattened, + ); + }, + list_sizes, + ), + ), + ]); + } + ) ) and gen_pat_sized = (_n: int): QCheck.Gen.t(pat) => QCheck.Gen.pure(WildPat); From 07105248993c1477cc2d849f704ebdc816cd2524 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 19 Dec 2024 12:30:58 -0500 Subject: [PATCH 157/281] More generator fixes and adjusted float equality --- src/haz3lmenhir/AST.re | 58 +++++++++++++++++++++++++++--------------- 1 file changed, 37 insertions(+), 21 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 72ebcc2d40..7b1d2a4ac6 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -1,13 +1,13 @@ open Sexplib.Std; -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type filter_action = | Pause | Debug | Hide | Eval; -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type op_bin_float = | Plus | Minus @@ -21,12 +21,12 @@ type op_bin_float = | Equals | NotEquals; -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type op_bin_bool = | And | Or; -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type op_bin_int = | Plus | Minus @@ -40,49 +40,49 @@ type op_bin_int = | Equals | NotEquals; -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type op_bin_string = | Concat | Equals; // TODO Rename to match others -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type binOp = | IntOp(op_bin_int) | FloatOp(op_bin_float) | StringOp(op_bin_string) | BoolOp(op_bin_bool); -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type op_un_meta = | Unquote; -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type op_un_int = | Minus; -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type op_un_bool = | Not; -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type op_un = | Meta(op_un_meta) | Int(op_un_int) | Bool(op_un_bool); -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type typ_provenance = | Internal | EmptyHole; -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type tpat = | InvalidTPat([@arb small_printable_gen] string) | EmptyHoleTPat | VarTPat(string); -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type typ = | IntType | StringType @@ -103,7 +103,7 @@ and sumterm = | BadEntry(typ) and sumtype = list(sumterm); -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type pat = | CastPat(pat, typ, typ) | EmptyHolePat @@ -120,20 +120,26 @@ type pat = | ApPat(pat, pat) | InvalidPat(string); -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type if_consistency = | Consistent | Inconsistent; -[@deriving (show({with_path: false}), sexp, qcheck)] +[@deriving (show({with_path: false}), sexp, qcheck, eq)] type deferral_pos = | InAp | OutsideAp; -[@deriving (show({with_path: false}), sexp)] +[@deriving (show({with_path: false}), sexp, eq)] type exp = | Int(int) - | Float(float) + | Float + // This equality condition is used to say that two floats are equal if they are equal in the ExpToSegment serialization + ( + [@equal + (a, b) => Printf.(sprintf("%.12f", a) == sprintf("%.12f", b)) + ] float, + ) | Var(string) | Constructor(string, typ) | String(string) @@ -271,6 +277,11 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => Gen.join( Gen.map( (sizes: array(int)) => { + let sizes = + switch (sizes) { + | [|single|] => [|(single - 1) / 2, (single - 1) / 2|] // Can't have singleton tuples. Replace this with a minimum parameter on list sizes + | _ => sizes + }; let exps = Array.map((size: int) => self(size), sizes); let flattened = Gen.flatten_a(exps); Gen.map( @@ -282,11 +293,16 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => ), ), Gen.map(exp => Test(exp), self(n - 1)), - Gen.map2( - (name, typ) => {Constructor(name, typ)}, + Gen.map( + name => Constructor(name, UnknownType(Internal)), arb_constructor_ident.gen, - gen_typ_sized(n - 1), ), + // TODO Ignoring typ because we don't serialize those + // Gen.map2( + // (name, typ) => {Constructor(name, typ)}, + // arb_constructor_ident.gen, + // gen_typ_sized(n - 1), + // ), Gen.map3( (op, e1, e2) => BinExp(e1, op, e2), gen_binOp, From d762a74e38ba4cb7bf0377fdfc5b7edb899a2b74 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 19 Dec 2024 14:26:07 -0500 Subject: [PATCH 158/281] Add deriving eq to menhir --- src/haz3lmenhir/dune | 1 + 1 file changed, 1 insertion(+) diff --git a/src/haz3lmenhir/dune b/src/haz3lmenhir/dune index 1169266987..d86a64d07e 100644 --- a/src/haz3lmenhir/dune +++ b/src/haz3lmenhir/dune @@ -9,6 +9,7 @@ ppx_let ppx_sexp_conv ppx_deriving.show + ppx_deriving.eq ppx_yojson_conv ppx_deriving_qcheck))) From 9eac896f90228990facb6f54b1b4d8724aa0ee39 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 19 Dec 2024 14:41:37 -0500 Subject: [PATCH 159/281] Remove space from testsuite name --- test/Test_Menhir.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 7cbc1c5c67..737d8a7cb4 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -341,7 +341,7 @@ let qcheck_menhir_serialized_equivalent_test = ); let tests = ( - "Menhir Parser", + "MenhirParser", [ parser_test("Integer Literal", Int(8) |> Exp.fresh, "8"), parser_test("Fun", fun_exp, "fun x -> x"), From 1e44f9c9598034930fa803dfa2fe1f6a3bb967da Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 19 Dec 2024 15:43:49 -0500 Subject: [PATCH 160/281] Add comment --- test/Test_Menhir.re | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 737d8a7cb4..30fa66b202 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -969,6 +969,8 @@ let ex5 = list_of_mylist(x) in |}, ), QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), + // Disabled due to bugs in ExpToSegment + // e.g. https://github.com/hazelgrove/hazel/issues/1445 // QCheck_alcotest.to_alcotest(qcheck_menhir_serialized_equivalent_test), ], ); From d535f5e07444902aac506163ab4169b7a2f13c47 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 19 Dec 2024 15:44:10 -0500 Subject: [PATCH 161/281] Add unit pattern --- src/haz3lmenhir/Parser.mly | 1 + 1 file changed, 1 insertion(+) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index f9247562e2..b3231dabab 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -258,6 +258,7 @@ pat: (* | p1 = pat; AS; p2 = pat; { AsPat(p1, p2) } *) | p1 = pat; CONS; p2 = pat { ConsPat(p1, p2) } | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } // TODO See if we can do multi arg pat ap without extra parens + | UNIT { TuplePat([]) } | p = nonAscriptingPat; { p } From ed36809746c9f584cede776d05abba3d52d35ff0 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 19 Dec 2024 15:44:20 -0500 Subject: [PATCH 162/281] More pattern generation --- src/haz3lmenhir/AST.re | 128 ++++++++++++++++++++++++++++++----------- 1 file changed, 93 insertions(+), 35 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 7b1d2a4ac6..0c109c7f8a 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -118,7 +118,7 @@ type pat = | ConsPat(pat, pat) | ListPat(list(pat)) | ApPat(pat, pat) - | InvalidPat(string); + | InvalidPat(string); // TODO Menhir parser doesn't actually support invalid pats [@deriving (show({with_path: false}), sexp, qcheck, eq)] type if_consistency = @@ -172,9 +172,8 @@ type exp = | TyAlias(tpat, typ, exp); let arb_int = QCheck.(map(x => Int(x), small_int)); - -let arb_str = - QCheck.(map(x => String(x), string_small_of(Gen.char_range('a', 'z')))); // Make strings anything other than `"`" +let arb_str = QCheck.(string_small_of(Gen.char_range('a', 'z'))); +let arb_str_exp = QCheck.map(x => String(x), arb_str); // Make strings anything other than `"`" // Floats are positive because we use UnOp minus let arb_float = QCheck.(map(x => Float(x), pos_float)); @@ -227,6 +226,15 @@ let arb_ident = ) ); +let list_sizes = n => + QCheck.Gen.( + switch (n) { + | 0 => pure([||]) + | 1 => pure([|0|]) + | _ => nat_split(~size=n, 5) // TODO Make different sized lists + } + ); + let arb_var = QCheck.(map(x => Var(x), arb_ident)); let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => @@ -234,7 +242,7 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => let leaf = oneof([ arb_int, - arb_str, + arb_str_exp, arb_float, arb_var, always(~print=show_exp, EmptyHole), @@ -246,19 +254,9 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => QCheck.Gen.fix( (self: int => Gen.t(exp), n) => { switch (n) { - | 0 => leaf.gen + | 0 + | 1 => leaf.gen | _ => - let list_sizes = - if (n <= 1) { - // Bug in nat_split for size=0 - Gen.pure([|0, 0, 0, 0, 0|]); - } else { - QCheck.Gen.nat_split( - ~size=n - 1, - 5 // Make different size lists - ); - }; - Gen.oneof([ leaf.gen, Gen.join( @@ -271,7 +269,7 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => flattened, ); }, - list_sizes, + list_sizes(n), ), ), Gen.join( @@ -289,7 +287,7 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => flattened, ); }, - list_sizes, + list_sizes(n), ), ), Gen.map(exp => Test(exp), self(n - 1)), @@ -322,7 +320,7 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => self((n - 1) / 3), self((n - 1) / 3), ), - ]); + ]) } }, n, @@ -343,17 +341,6 @@ and gen_typ_sized = switch (n) { | 0 => leaf_nodes | _ => - let list_sizes = - if (n <= 1) { - // Bug in nat_split for size=0 - pure([|0, 0, 0, 0, 0|]); - } else { - QCheck.Gen.nat_split( - ~size=n - 1, - 5 // Make different size lists - ); - }; - oneof([ leaf_nodes, join( @@ -367,15 +354,86 @@ and gen_typ_sized = flattened, ); }, - list_sizes, + list_sizes(n), ), ), - ]); + ]) } ) ) -and gen_pat_sized = (_n: int): QCheck.Gen.t(pat) => - QCheck.Gen.pure(WildPat); +and gen_pat_sized: int => QCheck.Gen.t(pat) = + /* + | CastPat(pat, typ, typ) + | EmptyHolePat + | WildPat + | IntPat(int) + | FloatPat(float) + | VarPat(string) + | StringPat(string) + | BoolPat(bool) + | ConstructorPat(string, typ) + | TuplePat(list(pat)) + | ConsPat(pat, pat) + | ListPat(list(pat)) + | ApPat(pat, pat) + | InvalidPat(string); + + */ + QCheck.Gen.( + fix((self, n) => { + let leaf_nodes = + oneof([ + return(WildPat), + return(EmptyHolePat), + map(x => IntPat(x), small_int), + map(x => FloatPat(x), QCheck.pos_float.gen), + map(x => VarPat(x), arb_ident.gen), + map(x => StringPat(x), arb_str.gen), + map(x => BoolPat(x), bool), + // map(x => InvalidPat(x), arb_str.gen), + map( + x => ConstructorPat(x, UnknownType(Internal)), + arb_constructor_ident.gen, + ), + ]); + + switch (n) { + | 0 => leaf_nodes + | _ => + oneof([ + leaf_nodes, + map2( + (p1, p2) => ConsPat(p1, p2), + self((n - 1) / 2), + self((n - 1) / 2), + ), + join( + map( + sizes => { + let pats = Array.map((size: int) => self(size), sizes); + + let flattened = flatten_a(pats); + + map(x => TuplePat(Array.to_list(x)), flattened); + }, + list_sizes(n - 1), + ), + ), + // map( + // pats => ListPat(pats), + // list_of_size(Gen.int_range(1, 5), self(n - 1)), + // ), + // map2((p1, p2) => ApPat(p1, p2), self(n - 1), self(n - 1)), + // map3( + // (p, t1, t2) => CastPat(p, t1, t2), + // self(n - 1), + // gen_typ_sized(n - 1), + // gen_typ_sized(n - 1), + // ), + ]) + }; + }) + ); // TODO Printers, shrinkers stuff let gen_exp = QCheck.Gen.sized(gen_exp_sized); From 0e3353d30a79cb7bb37acb76badec72fb9f19833 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 19 Dec 2024 16:07:26 -0500 Subject: [PATCH 163/281] Added CastPat and ApPat generators --- src/haz3lmenhir/AST.re | 206 +++++++++++++++++++++-------------------- 1 file changed, 105 insertions(+), 101 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 0c109c7f8a..fb9c8f4c06 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -328,112 +328,116 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => gen ) -and gen_typ_sized = - QCheck.Gen.( - let leaf_nodes = - oneof([ - return(StringType), - return(FloatType), - return(BoolType), - return(UnitType), - ]); - fix((self, n) => - switch (n) { - | 0 => leaf_nodes - | _ => +and gen_typ_sized: int => QCheck.Gen.t(typ) = + n => + QCheck.Gen.( + let leaf_nodes = oneof([ - leaf_nodes, - join( - map( - (sizes: array(int)) => { - let typs = Array.map((size: int) => self(size), sizes); - - let flattened = flatten_a(typs); + return(StringType), + return(FloatType), + return(BoolType), + return(UnitType), + ]); + fix( + (self, n) => + switch (n) { + | 0 => leaf_nodes + | _ => + oneof([ + leaf_nodes, + join( map( - (typs: array(typ)) => TupleType(Array.to_list(typs)), - flattened, - ); - }, - list_sizes(n), - ), - ), - ]) - } + (sizes: array(int)) => { + let typs = Array.map((size: int) => self(size), sizes); + + let flattened = flatten_a(typs); + map( + (typs: array(typ)) => TupleType(Array.to_list(typs)), + flattened, + ); + }, + list_sizes(n), + ), + ), + ]) + }, + n, + ) ) - ) and gen_pat_sized: int => QCheck.Gen.t(pat) = - /* - | CastPat(pat, typ, typ) - | EmptyHolePat - | WildPat - | IntPat(int) - | FloatPat(float) - | VarPat(string) - | StringPat(string) - | BoolPat(bool) - | ConstructorPat(string, typ) - | TuplePat(list(pat)) - | ConsPat(pat, pat) - | ListPat(list(pat)) - | ApPat(pat, pat) - | InvalidPat(string); - - */ - QCheck.Gen.( - fix((self, n) => { - let leaf_nodes = - oneof([ - return(WildPat), - return(EmptyHolePat), - map(x => IntPat(x), small_int), - map(x => FloatPat(x), QCheck.pos_float.gen), - map(x => VarPat(x), arb_ident.gen), - map(x => StringPat(x), arb_str.gen), - map(x => BoolPat(x), bool), - // map(x => InvalidPat(x), arb_str.gen), - map( - x => ConstructorPat(x, UnknownType(Internal)), - arb_constructor_ident.gen, - ), - ]); + n => + QCheck.Gen.( + fix( + (self, n) => { + let leaf_nodes = + oneof([ + return(WildPat), + return(EmptyHolePat), + map(x => IntPat(x), small_int), + map(x => FloatPat(x), QCheck.pos_float.gen), + map(x => VarPat(x), arb_ident.gen), + map(x => StringPat(x), arb_str.gen), + map(x => BoolPat(x), bool), + map( + x => ConstructorPat(x, UnknownType(Internal)), + arb_constructor_ident.gen, + ), + return(TuplePat([])), + return(ListPat([])), + ]); - switch (n) { - | 0 => leaf_nodes - | _ => - oneof([ - leaf_nodes, - map2( - (p1, p2) => ConsPat(p1, p2), - self((n - 1) / 2), - self((n - 1) / 2), - ), - join( - map( - sizes => { - let pats = Array.map((size: int) => self(size), sizes); - - let flattened = flatten_a(pats); - - map(x => TuplePat(Array.to_list(x)), flattened); - }, - list_sizes(n - 1), - ), - ), - // map( - // pats => ListPat(pats), - // list_of_size(Gen.int_range(1, 5), self(n - 1)), - // ), - // map2((p1, p2) => ApPat(p1, p2), self(n - 1), self(n - 1)), - // map3( - // (p, t1, t2) => CastPat(p, t1, t2), - // self(n - 1), - // gen_typ_sized(n - 1), - // gen_typ_sized(n - 1), - // ), - ]) - }; - }) - ); + switch (n) { + | 0 => leaf_nodes + | _ => + oneof([ + leaf_nodes, + map2( + (p1, p2) => ConsPat(p1, p2), + self((n - 1) / 2), + self((n - 1) / 2), + ), + join( + map( + sizes => { + let pats = Array.map((size: int) => self(size), sizes); + + let flattened = flatten_a(pats); + + map(x => TuplePat(Array.to_list(x)), flattened); + }, + list_sizes(n - 1), + ), + ), + join( + map( + sizes => { + let pats = Array.map((size: int) => self(size), sizes); + + let flattened = flatten_a(pats); + + map(x => ListPat(Array.to_list(x)), flattened); + }, + list_sizes(n - 1), + ), + ), + map2( + (p1, p2) => ApPat(p1, p2), + self((n - 1) / 2), + self((n - 1) / 2), + ), + map3( + (p, t1, t2) => CastPat(p, t1, t2), + self((n - 1) / 3), + gen_typ_sized((n - 1) / 3), + gen_typ_sized((n - 1) / 3), + ), + ]) + }; + }, + n, + ) + ); +// map(x => InvalidPat(x), arb_str.gen), // TODO Printers, shrinkers stuff let gen_exp = QCheck.Gen.sized(gen_exp_sized); From 57b3e8b9075d02bb222a73b79a25aa7de4607b1b Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Thu, 19 Dec 2024 16:20:51 -0500 Subject: [PATCH 164/281] Add ArrayType to generator --- src/haz3lmenhir/AST.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index fb9c8f4c06..26181c7150 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -359,6 +359,7 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = list_sizes(n), ), ), + map(t => ArrayType(t), self(n - 1)), ]) }, n, @@ -437,7 +438,6 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = n, ) ); -// map(x => InvalidPat(x), arb_str.gen), // TODO Printers, shrinkers stuff let gen_exp = QCheck.Gen.sized(gen_exp_sized); From 4a79a148a52a82266d5b038fa2d9a90f3500251a Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 09:10:51 -0500 Subject: [PATCH 165/281] More patterns --- src/haz3lmenhir/AST.re | 29 ++++++++++++++++++++++++++++- test/Test_Menhir.re | 17 +++++++++++++++-- 2 files changed, 43 insertions(+), 3 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 26181c7150..10746dc3e8 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -205,6 +205,8 @@ let arb_constructor_ident = ); // ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* +// Currently an issue if the keyword is a prefix of another word. `let ? = ina in ?` +// Temporarily doing single char identifiers as a fix let arb_ident = QCheck.( // TODO make this support full indent instead of just lower alpha @@ -222,7 +224,7 @@ let arb_ident = | "in" => "keyword" | _ => ident }, - string_gen_of_size(Gen.int_range(1, 5), arb_lower_alpha), + string_gen_of_size(Gen.int_range(1, 1), arb_lower_alpha), ) ); @@ -330,6 +332,19 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => ) and gen_typ_sized: int => QCheck.Gen.t(typ) = n => + /* + | SumTyp(sumtype) + | UnknownType(typ_provenance) + | ArrowType(typ, typ) + | TypVar(string) + | InvalidTyp(string) + | ForallType(tpat, typ) + | RecType(tpat, typ) + and sumterm = + | Variant(string, option(typ)) + | BadEntry(typ) + + */ QCheck.Gen.( let leaf_nodes = oneof([ @@ -348,6 +363,12 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = join( map( (sizes: array(int)) => { + let sizes = + switch (sizes) { + | [|single|] => [|(single - 1) / 2, (single - 1) / 2|] // Can't have singleton tuples. Replace this with a minimum parameter on list sizes + | _ => sizes + }; + let typs = Array.map((size: int) => self(size), sizes); let flattened = flatten_a(typs); @@ -400,6 +421,12 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = join( map( sizes => { + let sizes = + switch (sizes) { + | [|single|] => [|(single - 1) / 2, (single - 1) / 2|] // Can't have singleton tuples. Replace this with a minimum parameter on list sizes + | _ => sizes + }; + let pats = Array.map((size: int) => self(size), sizes); let flattened = flatten_a(pats); diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 30fa66b202..d16381acde 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -248,8 +248,8 @@ let i = ref(0); let qcheck_menhir_maketerm_equivalent_test = QCheck.Test.make( ~name="Menhir and maketerm are equivalent", - ~count=1000, - QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(4)), + ~count=100, + QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(7)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); @@ -266,6 +266,14 @@ let qcheck_menhir_maketerm_equivalent_test = |> Exp.fresh | _ => cont(e) }, + ~f_pat= + (cont, e) => + switch (e.term) { + | Tuple(es) => + Parens(Tuple(es |> List.map(cont)) |> Pat.fresh) + |> Pat.fresh + | _ => cont(e) + }, core_exp, ); @@ -968,6 +976,11 @@ let ex5 = list_of_mylist(x) in (ex1, ex2, ex3, ex4, ex5) |}, ), + // This fails because MakeTerm can't handle left to right keyword prefixes. + skip_menhir_maketerm_equivalent_test( + "Example failure", + {|let ? = ina in ?|} // let ? = ina in ? + ), QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), // Disabled due to bugs in ExpToSegment // e.g. https://github.com/hazelgrove/hazel/issues/1445 From 84360631ac8a421b0d1a1c2885254e4ed9a17956 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 09:34:46 -0500 Subject: [PATCH 166/281] Clean up qcheck generator --- src/haz3lmenhir/AST.re | 58 ++++++++++++++++++++++-------------------- 1 file changed, 30 insertions(+), 28 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 10746dc3e8..269ef77717 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -228,15 +228,34 @@ let arb_ident = ) ); -let list_sizes = n => +let sized_arr = (n: int) => QCheck.Gen.( - switch (n) { - | 0 => pure([||]) - | 1 => pure([|0|]) - | _ => nat_split(~size=n, 5) // TODO Make different sized lists - } + let list_size = n <= 1 ? pure(0) : int_range(2, n); + + list_size + >>= ( + x => + switch (x) { + | 0 => pure([||]) + | _ => nat_split(~size=x, n - x) + } + ) ); +let non_single_element_arr = (n: int) => + QCheck.Gen.( + let list_size = + frequency([(1, pure(0)), (n, n <= 1 ? pure(0) : int_range(2, n))]); + + list_size + >>= ( + x => + switch (x) { + | 0 => pure([||]) + | _ => nat_split(~size=x, n - x) + } + ) + ); let arb_var = QCheck.(map(x => Var(x), arb_ident)); let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => @@ -271,17 +290,12 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => flattened, ); }, - list_sizes(n), + sized_arr(n), ), ), Gen.join( Gen.map( (sizes: array(int)) => { - let sizes = - switch (sizes) { - | [|single|] => [|(single - 1) / 2, (single - 1) / 2|] // Can't have singleton tuples. Replace this with a minimum parameter on list sizes - | _ => sizes - }; let exps = Array.map((size: int) => self(size), sizes); let flattened = Gen.flatten_a(exps); Gen.map( @@ -289,7 +303,7 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => flattened, ); }, - list_sizes(n), + non_single_element_arr(n), ), ), Gen.map(exp => Test(exp), self(n - 1)), @@ -363,12 +377,6 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = join( map( (sizes: array(int)) => { - let sizes = - switch (sizes) { - | [|single|] => [|(single - 1) / 2, (single - 1) / 2|] // Can't have singleton tuples. Replace this with a minimum parameter on list sizes - | _ => sizes - }; - let typs = Array.map((size: int) => self(size), sizes); let flattened = flatten_a(typs); @@ -377,7 +385,7 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = flattened, ); }, - list_sizes(n), + non_single_element_arr(n), ), ), map(t => ArrayType(t), self(n - 1)), @@ -421,19 +429,13 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = join( map( sizes => { - let sizes = - switch (sizes) { - | [|single|] => [|(single - 1) / 2, (single - 1) / 2|] // Can't have singleton tuples. Replace this with a minimum parameter on list sizes - | _ => sizes - }; - let pats = Array.map((size: int) => self(size), sizes); let flattened = flatten_a(pats); map(x => TuplePat(Array.to_list(x)), flattened); }, - list_sizes(n - 1), + non_single_element_arr(n - 1), ), ), join( @@ -445,7 +447,7 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = map(x => ListPat(Array.to_list(x)), flattened); }, - list_sizes(n - 1), + sized_arr(n - 1), ), ), map2( From 9c31795fec09209270243d2bc85316c09e19866b Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 10:42:30 -0500 Subject: [PATCH 167/281] Make ExpToSegment more resilient to missing ids --- src/haz3lcore/pretty/ExpToSegment.re | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index 0cf8180f54..f11ae82a5e 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -543,10 +543,26 @@ and typ_to_pretty = (~settings: Settings.t, typ: Typ.t): pretty => { let go = typ_to_pretty(~settings: Settings.t); let go_constructor: ConstructorMap.variant(Typ.t) => pretty = fun - | Variant(c, ids, None) => text_to_pretty(List.hd(ids), Sort.Typ, c) + | Variant(c, ids, None) => { + print_endline("Here3"); + text_to_pretty( + Option.value(~default=Id.invalid, ListUtil.hd_opt(ids)), + Sort.Typ, + c, + ); + } | Variant(c, ids, Some(x)) => { + print_endline("Here"); let+ constructor = - text_to_pretty(List.hd(List.tl(ids)), Sort.Typ, c); + text_to_pretty( + Option.value( + ~default=Id.invalid, + ListUtil.hd_opt(List.tl(ids)), + ), + Sort.Typ, + c, + ); + print_endline("here2"); constructor @ [mk_form("ap_typ", List.hd(ids), [go(x)])]; } | BadEntry(x) => go(x); From cb0dac788b3fb6a21ec0f4e6699d07aa64814885 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 10:42:49 -0500 Subject: [PATCH 168/281] Add more typ generators --- src/haz3lmenhir/AST.re | 54 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 47 insertions(+), 7 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 269ef77717..1b1ec5cd72 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -347,17 +347,10 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => and gen_typ_sized: int => QCheck.Gen.t(typ) = n => /* - | SumTyp(sumtype) - | UnknownType(typ_provenance) - | ArrowType(typ, typ) - | TypVar(string) | InvalidTyp(string) - | ForallType(tpat, typ) - | RecType(tpat, typ) and sumterm = | Variant(string, option(typ)) | BadEntry(typ) - */ QCheck.Gen.( let leaf_nodes = @@ -366,6 +359,8 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = return(FloatType), return(BoolType), return(UnitType), + map(x => UnknownType(x), arb_typ_provenance.gen), + map(x => SumTyp([Variant(x, None)]), arb_constructor_ident.gen), ]); fix( (self, n) => @@ -389,6 +384,51 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = ), ), map(t => ArrayType(t), self(n - 1)), + map2( + (t1, t2) => ArrowType(t1, t2), + self((n - 1) / 2), + self((n - 1) / 2), + ), + map(x => TypVar(x), arb_ident.gen), + map2( + (tpat, t) => ForallType(tpat, t), + arb_tpat.gen, + self(n - 1), + ), + map2( + (tpat, t) => RecType(tpat, t), + arb_tpat.gen, + self(n - 1), + ), + join( + map( + sizes => { + let sumterms = + Array.map( + (size: int) => { + let optional_typ = option(self(size)); + let constructor = arb_constructor_ident.gen; + let variant = + map2( + (name, typ) => Variant(name, typ), + constructor, + optional_typ, + ); + frequency([ + (5, variant), + (1, return(BadEntry(UnknownType(EmptyHole)))), + ]); + }, + sizes, + ); + + let flattened: t(array(sumterm)) = flatten_a(sumterms); + + map(x => SumTyp(Array.to_list(x)), flattened); + }, + sized_arr(n - 1), + ), + ), ]) }, n, From dbc4d47957ca3790da55ec0516f641f8deb12576 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 10:43:08 -0500 Subject: [PATCH 169/281] Add test for exp to segment --- test/Test_ExpToSegment.re | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 test/Test_ExpToSegment.re diff --git a/test/Test_ExpToSegment.re b/test/Test_ExpToSegment.re new file mode 100644 index 0000000000..e365ab7ceb --- /dev/null +++ b/test/Test_ExpToSegment.re @@ -0,0 +1,31 @@ +open Alcotest; +open Haz3lcore; + +let tests = ( + "ExpToSegment", + [ + test_case( + "Empty Ids on ExpToSegment does not throw", + `Quick, + () => { + let _ = + ExpToSegment.exp_to_segment( + ~settings= + ExpToSegment.Settings.of_core(~inline=true, CoreSettings.off), + Let( + Cast( + ListLit([]) |> Pat.fresh, + Sum([Variant("Jg", [], None)]) |> Typ.fresh, + Float |> Typ.fresh, + ) + |> Pat.fresh, + EmptyHole |> Exp.fresh, + EmptyHole |> Exp.fresh, + ) + |> Exp.fresh, + ); + (); + }, + ), + ], +); From 5970942249e6b76c8b7e11071f64fa58b90c37d3 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 10:43:15 -0500 Subject: [PATCH 170/281] reformat --- src/haz3lmenhir/Parser.mly | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index b3231dabab..b1c8ca9804 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -218,7 +218,7 @@ sumTyp: typ: | c = CONSTRUCTOR_IDENT { TypVar(c) } | c = IDENT { TypVar(c) } - | T_TYP; s = STRING { InvalidTyp(s) } + | T_TYP; s = STRING { InvalidTyp(s) } | INT_TYPE { IntType } | FLOAT_TYPE { FloatType } | BOOL_TYPE { BoolType } From 524547fea11ddedc5dea9c246c195d9b440fe4d3 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 10:44:07 -0500 Subject: [PATCH 171/281] Add Test_ExpToSegment to test runner --- test/haz3ltest.re | 1 + 1 file changed, 1 insertion(+) diff --git a/test/haz3ltest.re b/test/haz3ltest.re index 043c496abb..a1050103e3 100644 --- a/test/haz3ltest.re +++ b/test/haz3ltest.re @@ -11,6 +11,7 @@ let (suite, _) = Test_Evaluator.tests, Test_ListUtil.tests, Test_MakeTerm.tests, + Test_ExpToSegment.tests, ] @ Test_Elaboration.tests, ); From d5db2dffd2f7efddc2dcae31fb5e3908275a11ff Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 11:04:44 -0500 Subject: [PATCH 172/281] Fix ApPat --- src/haz3lmenhir/Parser.mly | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index b1c8ca9804..a8fbddb955 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -248,6 +248,7 @@ nonAscriptingPat: | s = STRING { StringPat s} | TRUE { BoolPat true} | FALSE {BoolPat false} + | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } // TODO See if we can do multi arg pat ap without extra parens funPat: | OPEN_PAREN; p1 = pat; COLON; t1 = typ; CLOSE_PAREN; { CastPat(p1, t1, UnknownType(Internal)) } // TODO Shift/reduce conflict but I'm pretty sure the end parse state is the same either way @@ -257,7 +258,6 @@ pat: | p1 = pat; COLON; t1 = typ; { CastPat(p1, t1, UnknownType(Internal)) } (* | p1 = pat; AS; p2 = pat; { AsPat(p1, p2) } *) | p1 = pat; CONS; p2 = pat { ConsPat(p1, p2) } - | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } // TODO See if we can do multi arg pat ap without extra parens | UNIT { TuplePat([]) } | p = nonAscriptingPat; { p } From 80f744ff06c2518a443c2cdef71b91cf8053b4ab Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 11:04:59 -0500 Subject: [PATCH 173/281] Cleanup constructor generator --- src/haz3lmenhir/AST.re | 26 ++++++++++---------------- 1 file changed, 10 insertions(+), 16 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 1b1ec5cd72..bf1cc57b27 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -308,15 +308,9 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => ), Gen.map(exp => Test(exp), self(n - 1)), Gen.map( - name => Constructor(name, UnknownType(Internal)), + name => Constructor(name, UnknownType(Internal)), // TODO Ignoring typ because we don't serialize those in ExpToSegment arb_constructor_ident.gen, ), - // TODO Ignoring typ because we don't serialize those - // Gen.map2( - // (name, typ) => {Constructor(name, typ)}, - // arb_constructor_ident.gen, - // gen_typ_sized(n - 1), - // ), Gen.map3( (op, e1, e2) => BinExp(e1, op, e2), gen_binOp, @@ -336,6 +330,11 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => self((n - 1) / 3), self((n - 1) / 3), ), + Gen.map2( + (p, e): exp => Fun(p, e, None), + gen_pat_sized((n - 1) / 2), + self((n - 1) / 2), + ), ]) } }, @@ -346,12 +345,6 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => ) and gen_typ_sized: int => QCheck.Gen.t(typ) = n => - /* - | InvalidTyp(string) - and sumterm = - | Variant(string, option(typ)) - | BadEntry(typ) - */ QCheck.Gen.( let leaf_nodes = oneof([ @@ -491,9 +484,10 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = ), ), map2( - (p1, p2) => ApPat(p1, p2), - self((n - 1) / 2), - self((n - 1) / 2), + (i, p) => + ApPat(ConstructorPat(i, UnknownType(Internal)), p), // The parser only handles ApPat with a constructor + arb_constructor_ident.gen, + self(n - 1), ), map3( (p, t1, t2) => CastPat(p, t1, t2), From bd9fd3c5a1711e69aab9b703e71ec139f83b21fd Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 11:17:42 -0500 Subject: [PATCH 174/281] Fix a precedence --- src/haz3lmenhir/Parser.mly | 2 +- test/Test_Menhir.re | 14 +++++++++----- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index a8fbddb955..f90c211753 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -115,6 +115,7 @@ open AST %right SUM_TYP +%right CONS %left COLON %right DASH_ARROW @@ -134,7 +135,6 @@ open AST %left IN %left DOLLAR_SIGN -%right CONS %left AT_SYMBOL %left OPEN_PAREN CLOSE_PAREN diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index d16381acde..ec440d3bf5 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -248,14 +248,14 @@ let i = ref(0); let qcheck_menhir_maketerm_equivalent_test = QCheck.Test.make( ~name="Menhir and maketerm are equivalent", - ~count=100, + ~count=1000, QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(7)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); // TODO Maybe only do this when necessary. // TODO Check with Matthew if I'm using this correctly - // Add parens around tuples + // Add parens around tuples and parens around certain patterns let core_exp = Exp.map_term( ~f_exp= @@ -272,6 +272,10 @@ let qcheck_menhir_maketerm_equivalent_test = | Tuple(es) => Parens(Tuple(es |> List.map(cont)) |> Pat.fresh) |> Pat.fresh + | Cons(p1, p2) => + Parens(Cons(cont(p1), cont(p2)) |> Pat.fresh) |> Pat.fresh + | Cast(p, t1, t2) => + Parens(Cast(cont(p), t1, t2) |> Pat.fresh) |> Pat.fresh | _ => cont(e) }, core_exp, @@ -978,10 +982,10 @@ let ex5 = list_of_mylist(x) in ), // This fails because MakeTerm can't handle left to right keyword prefixes. skip_menhir_maketerm_equivalent_test( - "Example failure", - {|let ? = ina in ?|} // let ? = ina in ? + "Prefixed keyword parses", + {|let ? = ina in ?|}, ), - QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), + // QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), // Disabled due to bugs in ExpToSegment // e.g. https://github.com/hazelgrove/hazel/issues/1445 // QCheck_alcotest.to_alcotest(qcheck_menhir_serialized_equivalent_test), From 9839e5e6110db5d5026de8861b6bc91a21a97957 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 11:18:14 -0500 Subject: [PATCH 175/281] Back to a 100 tests --- test/Test_Menhir.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index ec440d3bf5..0dd4509a97 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -248,7 +248,7 @@ let i = ref(0); let qcheck_menhir_maketerm_equivalent_test = QCheck.Test.make( ~name="Menhir and maketerm are equivalent", - ~count=1000, + ~count=100, QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(7)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); From 0bba4b1ca170fd4aa52bf0075f46ad203363b674 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 11:36:44 -0500 Subject: [PATCH 176/281] Readd qcheck --- test/Test_Menhir.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 0dd4509a97..8904f03e27 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -985,7 +985,7 @@ let ex5 = list_of_mylist(x) in "Prefixed keyword parses", {|let ? = ina in ?|}, ), - // QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), + QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), // Disabled due to bugs in ExpToSegment // e.g. https://github.com/hazelgrove/hazel/issues/1445 // QCheck_alcotest.to_alcotest(qcheck_menhir_serialized_equivalent_test), From 54e19f4dcf31cc4a97ca45af85f5c02e00360f04 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 11:51:56 -0500 Subject: [PATCH 177/281] Enhance ExpToSegment tests with constructor and match statement cases --- test/Test_ExpToSegment.re | 56 ++++++++++++++++++++++++++++++++++----- 1 file changed, 50 insertions(+), 6 deletions(-) diff --git a/test/Test_ExpToSegment.re b/test/Test_ExpToSegment.re index e365ab7ceb..505cfc281f 100644 --- a/test/Test_ExpToSegment.re +++ b/test/Test_ExpToSegment.re @@ -1,17 +1,21 @@ open Alcotest; open Haz3lcore; +let segmentize = + ExpToSegment.exp_to_segment( + ~settings=ExpToSegment.Settings.of_core(~inline=true, CoreSettings.off), + _, + ); + let tests = ( "ExpToSegment", [ test_case( - "Empty Ids on ExpToSegment does not throw", + "Empty Ids on ExpToSegment constructor", `Quick, () => { - let _ = - ExpToSegment.exp_to_segment( - ~settings= - ExpToSegment.Settings.of_core(~inline=true, CoreSettings.off), + let segment = + segmentize( Let( Cast( ListLit([]) |> Pat.fresh, @@ -24,7 +28,47 @@ let tests = ( ) |> Exp.fresh, ); - (); + let serialized = Printer.of_segment(~holes=Some("?"), segment); + + check( + string, + "ascribed sum type constructor in pattern", + serialized, + "let []: (+ Jg) = ? in ?", + ); + }, + ), + test_case( + "Match statement", + `Quick, + () => { + let segment = + segmentize( + Match( + Var("x") |> Exp.fresh, + [ + ( + Constructor("A", Unknown(Internal) |> Typ.fresh) + |> Pat.fresh, + Int(1) |> Exp.fresh, + ), + ( + Constructor("B", Unknown(Internal) |> Typ.fresh) + |> Pat.fresh, + Int(2) |> Exp.fresh, + ), + ], + ) + |> Exp.fresh, + ); + let serialized = Printer.of_segment(~holes=Some("?"), segment); + + check( + string, + "Match statement", + serialized, + "case x end" // TODO Why is this not serializing the cases + ); }, ), ], From f5595e7c69787ab4b13de204b3c98e9b4d1b7786 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 11:52:20 -0500 Subject: [PATCH 178/281] Add case generation for expressions --- src/haz3lmenhir/AST.re | 55 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index bf1cc57b27..6fccde505a 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -335,6 +335,61 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => gen_pat_sized((n - 1) / 2), self((n - 1) / 2), ), + Gen.( + let e = self(n - 1 / 2); + let case = n => { + print_endline("Case size" ++ string_of_int(n)); + let p = gen_pat_sized(n / 2); + let e = self(n / 2); + tup2(p, e); + }; + + let cases = + sized_arr(n - 1 / 2) + >>= ( + sizes => { + print_endline( + "Case sizes" ++ [%derive.show: array(int)](sizes), + ); + let cases: QCheck.Gen.t(array((pat, exp))) = + flatten_a(Array.map(case, sizes)); + cases; + } + ); + tup2(e, cases) + >|= ( + ((e, cases)) => { + print_endline( + "Cases: " ++ [%derive.show: array((pat, exp))](cases), + ); + CaseExp(e, Array.to_list(cases)); + } + ) + ), + /* + | CaseExp(exp, list((pat, exp))) + | ApExp(exp, exp) + | FixF(pat, exp) + | Bool(bool) + | Cast(exp, typ, typ) + | FailedCast(exp, typ, typ) + | EmptyHole + | Filter(filter_action, exp, exp) + | BuiltinFun(string) + | Undefined + | Seq(exp, exp) + | Test(exp) + | Deferral + | TypFun(tpat, exp) + | Cons(exp, exp) + | ListConcat(exp, exp) + | If(exp, exp, exp) + | InvalidExp(string) + | TypAp(exp, typ) + | DynamicErrorHole(exp, string) + | TyAlias(tpat, typ, exp); + + */ ]) } }, From 618a4d9340808dbf40fe8a0b34560857fcd4e814 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 11:56:44 -0500 Subject: [PATCH 179/281] More expression generation --- src/haz3lmenhir/AST.re | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 6fccde505a..b6a566ace9 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -266,6 +266,7 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => arb_str_exp, arb_float, arb_var, + map(x => Bool(x), bool), always(~print=show_exp, EmptyHole), always(~print=show_exp, TupleExp([])), always(~print=show_exp, ListExp([])), @@ -338,7 +339,6 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => Gen.( let e = self(n - 1 / 2); let case = n => { - print_endline("Case size" ++ string_of_int(n)); let p = gen_pat_sized(n / 2); let e = self(n / 2); tup2(p, e); @@ -348,9 +348,6 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => sized_arr(n - 1 / 2) >>= ( sizes => { - print_endline( - "Case sizes" ++ [%derive.show: array(int)](sizes), - ); let cases: QCheck.Gen.t(array((pat, exp))) = flatten_a(Array.map(case, sizes)); cases; @@ -359,18 +356,21 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => tup2(e, cases) >|= ( ((e, cases)) => { - print_endline( - "Cases: " ++ [%derive.show: array((pat, exp))](cases), - ); CaseExp(e, Array.to_list(cases)); } ) ), + Gen.map2( + (e1, e2) => ApExp(e1, e2), + self((n - 1) / 2), + self((n - 1) / 2), + ), + Gen.map2( + (p, e) => FixF(p, e), + gen_pat_sized((n - 1) / 2), + self((n - 1) / 2), + ), /* - | CaseExp(exp, list((pat, exp))) - | ApExp(exp, exp) - | FixF(pat, exp) - | Bool(bool) | Cast(exp, typ, typ) | FailedCast(exp, typ, typ) | EmptyHole From c9556ef65f07754a72fa1f494598fd029db712d9 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 12:08:02 -0500 Subject: [PATCH 180/281] Added deferrals and filters to generators --- src/haz3lmenhir/AST.re | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index b6a566ace9..8f1204d51d 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -363,21 +363,32 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => Gen.map2( (e1, e2) => ApExp(e1, e2), self((n - 1) / 2), - self((n - 1) / 2), + Gen.frequency([ + (5, self((n - 1) / 2)), + (1, Gen.return(Deferral)), + ]), ), Gen.map2( (p, e) => FixF(p, e), gen_pat_sized((n - 1) / 2), self((n - 1) / 2), ), + Gen.( + let* fa = gen_filter_action; + let* e1 = self(n - 1); + let+ e2 = self(n - 1); + Filter(fa, e1, e2) + ), + // Gen.( + // let* e1 = self((n - 1) / 2); + // let+ e2 = self((n - 1) / 2); + // Seq(e1, e2) + // ), + // Cast expressions not supported by menhir grammar yet /* - | Cast(exp, typ, typ) - | FailedCast(exp, typ, typ) - | EmptyHole | Filter(filter_action, exp, exp) | BuiltinFun(string) | Undefined - | Seq(exp, exp) | Test(exp) | Deferral | TypFun(tpat, exp) From f3e43496c4856ef6772f0eccf19dd47f23f25cc6 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 12:30:31 -0500 Subject: [PATCH 181/281] Adjust if precedence --- src/haz3lmenhir/Parser.mly | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index f90c211753..fc28650510 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -109,7 +109,6 @@ open AST -%nonassoc IF_EXP %nonassoc LET_EXP %right SEMI_COLON @@ -119,6 +118,8 @@ open AST %left COLON %right DASH_ARROW +%nonassoc IF_EXP + %right L_OR // TODO Check with Milan. I moved this to make tests pass. %right L_AND %right L_NOT From d0a7a7615b7543ab7567e051b580ae9c351bd79a Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 12:30:40 -0500 Subject: [PATCH 182/281] Generate sequences --- src/haz3lmenhir/AST.re | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 8f1204d51d..da396a0328 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -379,11 +379,11 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => let+ e2 = self(n - 1); Filter(fa, e1, e2) ), - // Gen.( - // let* e1 = self((n - 1) / 2); - // let+ e2 = self((n - 1) / 2); - // Seq(e1, e2) - // ), + Gen.( + let* e1 = self((n - 1) / 2); + let+ e2 = self((n - 1) / 2); + Seq(e1, e2) + ), // Cast expressions not supported by menhir grammar yet /* | Filter(filter_action, exp, exp) From 680a25c2b7c59432c5ce5fe3d081735f0f5ef828 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 12:42:35 -0500 Subject: [PATCH 183/281] Precedence of cons --- src/haz3lmenhir/Parser.mly | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index fc28650510..2b382ee16a 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -114,7 +114,6 @@ open AST %right SUM_TYP -%right CONS %left COLON %right DASH_ARROW @@ -127,6 +126,7 @@ open AST %left GREATER_THAN LESS_THAN DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT DOUBLE_EQUAL_FLOAT STRING_EQUAL %right STRING_CONCAT +%right CONS %left PLUS MINUS PLUS_FLOAT MINUS_FLOAT %left DIVIDE TIMES TIMES_FLOAT DIVIDE_FLOAT %right POWER POWER_FLOAT From 419f9e3d42fe5704fef50d2997ec95d00e9f3715 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 12:42:47 -0500 Subject: [PATCH 184/281] Generate cons --- src/haz3lmenhir/AST.re | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index da396a0328..6f06c43cdb 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -384,18 +384,18 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => let+ e2 = self((n - 1) / 2); Seq(e1, e2) ), - // Cast expressions not supported by menhir grammar yet + Gen.( + let* e1 = self((n - 1) / 2); + let+ e2 = self((n - 1) / 2); + Cons(e1, e2) + ), + // Gen.( + // let* e1 = self((n - 1) / 2); + // let+ e2 = self((n - 1) / 2); + // ListConcat(e1, e2) + // ), /* - | Filter(filter_action, exp, exp) - | BuiltinFun(string) - | Undefined - | Test(exp) - | Deferral | TypFun(tpat, exp) - | Cons(exp, exp) - | ListConcat(exp, exp) - | If(exp, exp, exp) - | InvalidExp(string) | TypAp(exp, typ) | DynamicErrorHole(exp, string) | TyAlias(tpat, typ, exp); From 1f06f00086e69a7c49e19891908f24cab0b70488 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 12:58:20 -0500 Subject: [PATCH 185/281] enable ListConcat generation --- src/haz3lmenhir/AST.re | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 6f06c43cdb..40754bdda9 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -389,11 +389,11 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => let+ e2 = self((n - 1) / 2); Cons(e1, e2) ), - // Gen.( - // let* e1 = self((n - 1) / 2); - // let+ e2 = self((n - 1) / 2); - // ListConcat(e1, e2) - // ), + Gen.( + let* e1 = self((n - 1) / 2); + let+ e2 = self((n - 1) / 2); + ListConcat(e1, e2) + ), /* | TypFun(tpat, exp) | TypAp(exp, typ) From 21d34fe218e1e8dc5290ed47fa1c3333d82db8ac Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 13:05:25 -0500 Subject: [PATCH 186/281] Fix tpat arb instance --- src/haz3lmenhir/AST.re | 30 ++++++++++++++++++++---------- 1 file changed, 20 insertions(+), 10 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 40754bdda9..b382531930 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -1,5 +1,7 @@ open Sexplib.Std; +let arb_str = QCheck.(string_small_of(Gen.char_range('a', 'z'))); + [@deriving (show({with_path: false}), sexp, qcheck, eq)] type filter_action = | Pause @@ -78,9 +80,9 @@ type typ_provenance = [@deriving (show({with_path: false}), sexp, qcheck, eq)] type tpat = - | InvalidTPat([@arb small_printable_gen] string) + | InvalidTPat([@arb arb_string] string) | EmptyHoleTPat - | VarTPat(string); + | VarTPat([@arb arb_string] string); [@deriving (show({with_path: false}), sexp, qcheck, eq)] type typ = @@ -172,7 +174,6 @@ type exp = | TyAlias(tpat, typ, exp); let arb_int = QCheck.(map(x => Int(x), small_int)); -let arb_str = QCheck.(string_small_of(Gen.char_range('a', 'z'))); let arb_str_exp = QCheck.map(x => String(x), arb_str); // Make strings anything other than `"`" // Floats are positive because we use UnOp minus @@ -394,13 +395,22 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => let+ e2 = self((n - 1) / 2); ListConcat(e1, e2) ), - /* - | TypFun(tpat, exp) - | TypAp(exp, typ) - | DynamicErrorHole(exp, string) - | TyAlias(tpat, typ, exp); - - */ + Gen.( + let* tp = arb_tpat.gen; + let+ e = self(n - 1); + TypFun(tp, e) + ), + Gen.( + let* t = gen_typ_sized((n - 1) / 2); + let+ e = self((n - 1) / 2); + TypAp(e, t) + ), + Gen.( + let* tp = arb_tpat.gen; + let* t = gen_typ_sized((n - 1) / 2); + let+ e = self((n - 1) / 2); + TyAlias(tp, t, e) + ), ]) } }, From bea13f76dce29ded7e951c60d50965f62df624ee Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 13:25:30 -0500 Subject: [PATCH 187/281] Refactor tpat and pat types; simplify arb generation and remove unused qcheck derivation --- src/haz3lmenhir/AST.re | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index b382531930..a813e127e8 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -78,13 +78,13 @@ type typ_provenance = | Internal | EmptyHole; -[@deriving (show({with_path: false}), sexp, qcheck, eq)] +[@deriving (show({with_path: false}), sexp, eq)] type tpat = - | InvalidTPat([@arb arb_string] string) + | InvalidTPat(string) | EmptyHoleTPat - | VarTPat([@arb arb_string] string); + | VarTPat(string); -[@deriving (show({with_path: false}), sexp, qcheck, eq)] +[@deriving (show({with_path: false}), sexp, eq)] type typ = | IntType | StringType @@ -105,7 +105,7 @@ and sumterm = | BadEntry(typ) and sumtype = list(sumterm); -[@deriving (show({with_path: false}), sexp, qcheck, eq)] +[@deriving (show({with_path: false}), sexp, eq)] type pat = | CastPat(pat, typ, typ) | EmptyHolePat @@ -259,6 +259,14 @@ let non_single_element_arr = (n: int) => ); let arb_var = QCheck.(map(x => Var(x), arb_ident)); +let gen_tpat = + QCheck.Gen.( + let gen_var = map(x => VarTPat(x), arb_ident.gen); + let gen_empty = pure(EmptyHoleTPat); + let gen_invalid = map(x => InvalidTPat(x), arb_str.gen); + oneof([gen_var, gen_empty, gen_invalid]) + ); + let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => QCheck.( let leaf = @@ -395,18 +403,14 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => let+ e2 = self((n - 1) / 2); ListConcat(e1, e2) ), - Gen.( - let* tp = arb_tpat.gen; - let+ e = self(n - 1); - TypFun(tp, e) - ), + Gen.(let* tp = gen_tpat; let+ e = self(n - 1); TypFun(tp, e)), Gen.( let* t = gen_typ_sized((n - 1) / 2); let+ e = self((n - 1) / 2); TypAp(e, t) ), Gen.( - let* tp = arb_tpat.gen; + let* tp = gen_tpat; let* t = gen_typ_sized((n - 1) / 2); let+ e = self((n - 1) / 2); TyAlias(tp, t, e) @@ -461,14 +465,10 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = map(x => TypVar(x), arb_ident.gen), map2( (tpat, t) => ForallType(tpat, t), - arb_tpat.gen, - self(n - 1), - ), - map2( - (tpat, t) => RecType(tpat, t), - arb_tpat.gen, + gen_tpat, self(n - 1), ), + map2((tpat, t) => RecType(tpat, t), gen_tpat, self(n - 1)), join( map( sizes => { From 21bcfbf7218a641ad85710e1267f6038778885fe Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 13:25:46 -0500 Subject: [PATCH 188/281] Add failing test for concat and typap --- test/Test_Menhir.re | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 8904f03e27..c1bcd387aa 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -985,7 +985,16 @@ let ex5 = list_of_mylist(x) in "Prefixed keyword parses", {|let ? = ina in ?|}, ), - QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), + // Menhir is doing this better than MakeTerm + skip_menhir_maketerm_equivalent_test( + "Prefixed keyword parses", + {|type ? = rec ? -> + Aramj -> Bool in ?|}, + ), + menhir_maketerm_equivalent_test( + "List concat and typap", + {|(true, 8, 0.000178) @ true @< (rec gxxow -> ()) >|}, + ), + // QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), // Disabled due to bugs in ExpToSegment // e.g. https://github.com/hazelgrove/hazel/issues/1445 // QCheck_alcotest.to_alcotest(qcheck_menhir_serialized_equivalent_test), From 28d60bdeea0afce550f7f580359ff139c6b83ccc Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 13:45:02 -0500 Subject: [PATCH 189/281] Fix TypAp with lexing operator --- src/haz3lmenhir/Lexer.mll | 1 + src/haz3lmenhir/Parser.mly | 4 +++- test/Test_Elaboration.re | 2 +- 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index 5bcc4270b8..289d0c6b30 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -115,6 +115,7 @@ rule token = | ";" {SEMI_COLON} | "test" {TEST} | "::" { CONS } + | "@<" {TYP_AP_SYMBOL} | "@" {AT_SYMBOL} | "?" {QUESTION} | "_" {WILD} diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 2b382ee16a..c828a02bf0 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -23,6 +23,7 @@ open AST %token WILD %token QUESTION %token AT_SYMBOL +%token TYP_AP_SYMBOL %token CONS %token TEST %token PAUSE @@ -137,6 +138,7 @@ open AST %left DOLLAR_SIGN %left AT_SYMBOL +%nonassoc TYP_AP_SYMBOL %left OPEN_PAREN CLOSE_PAREN %left QUESTION @@ -328,7 +330,7 @@ exp: | e1 = exp; SEMI_COLON; e2 = exp { Seq(e1, e2) } | E_EXP; s = STRING; { InvalidExp(s) } | WILD {Deferral} - | e = exp; AT_SYMBOL; LESS_THAN; ty = typ; GREATER_THAN; {TypAp(e, ty)} + | e = exp; TYP_AP_SYMBOL; ty = typ; GREATER_THAN; {TypAp(e, ty)} | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} | LESS_THAN; LESS_THAN; e = exp; QUESTION; s = SEXP_STRING; GREATER_THAN; GREATER_THAN {DynamicErrorHole(e, s)} | b = BUILTIN; {BuiltinFun(b)} diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index 406c913d34..e12114ad66 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -534,7 +534,7 @@ let f = let_exp_uexp, ); - let typ_ap_str = "(typfun x -> 4) @ "; + let typ_ap_str = "(typfun x -> 4)@"; let typ_ap_uexp: Exp.t = TypAp( TypFun(Var("x") |> TPat.fresh, Int(4) |> Exp.fresh, None) |> Exp.fresh, From cfda14872c7cde62c6afe44f7dd02015a827c1cb Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 13:58:51 -0500 Subject: [PATCH 190/281] Remove debug code --- src/haz3lcore/pretty/ExpToSegment.re | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index f11ae82a5e..a1fcabd1d4 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -544,7 +544,6 @@ and typ_to_pretty = (~settings: Settings.t, typ: Typ.t): pretty => { let go_constructor: ConstructorMap.variant(Typ.t) => pretty = fun | Variant(c, ids, None) => { - print_endline("Here3"); text_to_pretty( Option.value(~default=Id.invalid, ListUtil.hd_opt(ids)), Sort.Typ, @@ -552,7 +551,6 @@ and typ_to_pretty = (~settings: Settings.t, typ: Typ.t): pretty => { ); } | Variant(c, ids, Some(x)) => { - print_endline("Here"); let+ constructor = text_to_pretty( Option.value( @@ -562,7 +560,6 @@ and typ_to_pretty = (~settings: Settings.t, typ: Typ.t): pretty => { Sort.Typ, c, ); - print_endline("here2"); constructor @ [mk_form("ap_typ", List.hd(ids), [go(x)])]; } | BadEntry(x) => go(x); From 88341f3a4743dd98ffc23d41815fcd0a34ef2b51 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 14:22:48 -0500 Subject: [PATCH 191/281] List concat/cons precedence --- src/haz3lmenhir/Parser.mly | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index c828a02bf0..8146ecab9c 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -127,9 +127,11 @@ open AST %left GREATER_THAN LESS_THAN DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT DOUBLE_EQUAL_FLOAT STRING_EQUAL %right STRING_CONCAT -%right CONS -%left PLUS MINUS PLUS_FLOAT MINUS_FLOAT -%left DIVIDE TIMES TIMES_FLOAT DIVIDE_FLOAT +%right CONS + +%left AT_SYMBOL PLUS MINUS PLUS_FLOAT MINUS_FLOAT +%left DIVIDE TIMES TIMES_FLOAT DIVIDE_FLOAT + %right POWER POWER_FLOAT %left OPEN_CURLY @@ -137,7 +139,6 @@ open AST %left IN %left DOLLAR_SIGN -%left AT_SYMBOL %nonassoc TYP_AP_SYMBOL %left OPEN_PAREN CLOSE_PAREN @@ -331,7 +332,7 @@ exp: | E_EXP; s = STRING; { InvalidExp(s) } | WILD {Deferral} | e = exp; TYP_AP_SYMBOL; ty = typ; GREATER_THAN; {TypAp(e, ty)} - | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} + | TYP; tp = tpat; SINGLE_EQUAL; ty = typ; IN; e = exp {TyAlias(tp, ty, e)} %prec LET_EXP | LESS_THAN; LESS_THAN; e = exp; QUESTION; s = SEXP_STRING; GREATER_THAN; GREATER_THAN {DynamicErrorHole(e, s)} | b = BUILTIN; {BuiltinFun(b)} | UNDEF; {Undefined} From 2936215321c8b495c879df788632eb42f7c1e6ac Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:00:05 -0500 Subject: [PATCH 192/281] ExpToSegment more resilient without ids --- src/haz3lcore/pretty/ExpToSegment.re | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index a1fcabd1d4..9e88bcbd73 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -553,14 +553,18 @@ and typ_to_pretty = (~settings: Settings.t, typ: Typ.t): pretty => { | Variant(c, ids, Some(x)) => { let+ constructor = text_to_pretty( - Option.value( - ~default=Id.invalid, - ListUtil.hd_opt(List.tl(ids)), - ), + Option.value(~default=Id.invalid, ListUtil.nth_opt(1, ids)), Sort.Typ, c, ); - constructor @ [mk_form("ap_typ", List.hd(ids), [go(x)])]; + constructor + @ [ + mk_form( + "ap_typ", + Option.value(~default=Id.invalid, ListUtil.hd_opt(ids)), + [go(x)], + ), + ]; } | BadEntry(x) => go(x); switch (typ |> Typ.term_of) { From 9fd16cce6fd8fd711de3d36083a1e38539fb4d24 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:00:24 -0500 Subject: [PATCH 193/281] sum types non-empty generator --- src/haz3lmenhir/AST.re | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index a813e127e8..006bce897a 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -257,14 +257,29 @@ let non_single_element_arr = (n: int) => } ) ); + +let non_empty_arr = (n: int) => + QCheck.Gen.( + let list_size = n <= 1 ? pure(0) : int_range(1, n); + + list_size + >>= ( + x => + switch (x) { + | 0 => pure([|0|]) // I'm a bit concerned about this not tracking size. But it seems to work in practice. + | _ => nat_split(~size=x, n - x) + } + ) + ); + let arb_var = QCheck.(map(x => Var(x), arb_ident)); let gen_tpat = QCheck.Gen.( let gen_var = map(x => VarTPat(x), arb_ident.gen); let gen_empty = pure(EmptyHoleTPat); - let gen_invalid = map(x => InvalidTPat(x), arb_str.gen); - oneof([gen_var, gen_empty, gen_invalid]) + // let gen_invalid = map(x => InvalidTPat(x), arb_ident.gen); + oneof([gen_var, gen_empty]) ); let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => @@ -495,7 +510,7 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = map(x => SumTyp(Array.to_list(x)), flattened); }, - sized_arr(n - 1), + non_empty_arr(n - 1), ), ), ]) From 1ce51446b61fc2eb56037044ce3ccae1ea579c9e Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:00:51 -0500 Subject: [PATCH 194/281] Add parens to tuples, sums, and records when converting --- src/haz3lmenhir/Conversion.re | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 7c46130626..fce3a03016 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -378,7 +378,8 @@ and Typ: { } | TypVar(s) => Var(s) | TupleType([t]) => Parens(of_menhir_ast(t)) - | TupleType(ts) => Prod(List.map(of_menhir_ast, ts)) + | TupleType(ts) => + Parens(Prod(List.map(of_menhir_ast, ts)) |> Haz3lcore.Typ.fresh) | ArrayType(t) => List(of_menhir_ast(t)) | ArrowType(t1, t2) => Arrow(of_menhir_ast(t1), of_menhir_ast(t2)) | SumTyp(sumterms) => @@ -393,9 +394,12 @@ and Typ: { }, sumterms, ); - Sum(converted_terms); + Parens(Sum(converted_terms) |> Typ.fresh); // Adds parens due to MakeTerm | ForallType(tp, t) => Forall(TPat.of_menhir_ast(tp), of_menhir_ast(t)) - | RecType(tp, t) => Rec(TPat.of_menhir_ast(tp), of_menhir_ast(t)) + | RecType(tp, t) => + Parens( + Rec(TPat.of_menhir_ast(tp), of_menhir_ast(t)) |> Haz3lcore.Typ.fresh, + ) // Parens because of (rec ? -> Bool, ()) }; }; let of_core_type_provenance = @@ -466,7 +470,8 @@ and Pat: { | VarPat(x) => Var(x) | ConstructorPat(x, ty) => Constructor(x, Typ.of_menhir_ast(ty)) | StringPat(s) => String(s) - | TuplePat(pats) => Tuple(List.map(of_menhir_ast, pats)) + | TuplePat(pats) => + Parens(Tuple(List.map(of_menhir_ast, pats)) |> Haz3lcore.Pat.fresh) | ApPat(pat1, pat2) => Ap(of_menhir_ast(pat1), of_menhir_ast(pat2)) | ConsPat(p1, p2) => Cons(of_menhir_ast(p1), of_menhir_ast(p2)) | BoolPat(b) => Bool(b) From d508eecc259aed95d219f6e4551e3147b1e2bef4 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:01:00 -0500 Subject: [PATCH 195/281] Adjust cast precedence --- src/haz3lmenhir/Parser.mly | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 8146ecab9c..1e63804f44 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -116,7 +116,6 @@ open AST %right SUM_TYP -%left COLON %right DASH_ARROW %nonassoc IF_EXP @@ -133,6 +132,7 @@ open AST %left DIVIDE TIMES TIMES_FLOAT DIVIDE_FLOAT %right POWER POWER_FLOAT +%left COLON %left OPEN_CURLY @@ -321,7 +321,7 @@ exp: | TRUE { Bool true } | f = funExp {f} | FALSE { Bool false } - | FIX; p = pat; DASH_ARROW; e = exp { FixF(p, e) } + | FIX; p = funPat; DASH_ARROW; e = exp { FixF(p, e) } | TYP_FUN; t = tpat; DASH_ARROW; e = exp {TypFun(t, e)} | QUESTION { EmptyHole } | a = filterAction; cond = exp; IN; body = exp { Filter(a, cond, body)} From 00592894259026068baa0b9cb929903b9ebc7199 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:23:51 -0500 Subject: [PATCH 196/281] Add parens around forall and rectype to help with ambiguities --- src/haz3lmenhir/Conversion.re | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index fce3a03016..dc481e951e 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -395,7 +395,11 @@ and Typ: { sumterms, ); Parens(Sum(converted_terms) |> Typ.fresh); // Adds parens due to MakeTerm - | ForallType(tp, t) => Forall(TPat.of_menhir_ast(tp), of_menhir_ast(t)) + | ForallType(tp, t) => + Parens( + Forall(TPat.of_menhir_ast(tp), of_menhir_ast(t)) + |> Haz3lcore.Typ.fresh, + ) | RecType(tp, t) => Parens( Rec(TPat.of_menhir_ast(tp), of_menhir_ast(t)) |> Haz3lcore.Typ.fresh, From c485ea5b6dbc1b31481f7c041ec7e3da38c94e09 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:24:20 -0500 Subject: [PATCH 197/281] Address some remaining inconsistencies with generation --- test/Test_Menhir.re | 40 ++++++++++++++++++++++++++++++++-------- 1 file changed, 32 insertions(+), 8 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index c1bcd387aa..79d59187c8 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -252,10 +252,10 @@ let qcheck_menhir_maketerm_equivalent_test = QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(7)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); - // TODO Maybe only do this when necessary. // TODO Check with Matthew if I'm using this correctly // Add parens around tuples and parens around certain patterns + // Move this to conversion let core_exp = Exp.map_term( ~f_exp= @@ -278,6 +278,15 @@ let qcheck_menhir_maketerm_equivalent_test = Parens(Cast(cont(p), t1, t2) |> Pat.fresh) |> Pat.fresh | _ => cont(e) }, + ~f_typ= + (cont, e) => + switch (e.term) { + | Rec(x, t) => + Parens(Rec(x, cont(t)) |> Typ.fresh) |> Typ.fresh + | Sum(cs) => Parens(Sum(cs) |> Typ.fresh) |> Typ.fresh + | Prod(ts) => Parens(Prod(ts) |> Typ.fresh) |> Typ.fresh + | _ => cont(e) + }, core_exp, ); @@ -302,8 +311,15 @@ let qcheck_menhir_maketerm_equivalent_test = print_endline( "Menhir parsed: " ++ DHExp.show(menhir_parsed_converted), ); - - Haz3lcore.DHExp.fast_equal(make_term_parsed, menhir_parsed_converted); + switch ( + Haz3lcore.DHExp.fast_equal(make_term_parsed, menhir_parsed_converted) + ) { + | true => true + | false => false + | exception (Failure(msg)) => + print_endline("Error: " ++ msg); + msg == "Sum type has non-unique constructors"; + }; }, ); @@ -312,7 +328,7 @@ let qcheck_menhir_maketerm_equivalent_test = let qcheck_menhir_serialized_equivalent_test = QCheck.Test.make( ~name="Menhir through ExpToSegment and back", - ~count=100, + ~count=1000, QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(4)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); @@ -985,16 +1001,24 @@ let ex5 = list_of_mylist(x) in "Prefixed keyword parses", {|let ? = ina in ?|}, ), - // Menhir is doing this better than MakeTerm + // Menhir is doing the skipped better than MakeTerm skip_menhir_maketerm_equivalent_test( "Prefixed keyword parses", {|type ? = rec ? -> + Aramj -> Bool in ?|}, ), - menhir_maketerm_equivalent_test( + skip_menhir_maketerm_equivalent_test( "List concat and typap", - {|(true, 8, 0.000178) @ true @< (rec gxxow -> ()) >|}, + {|type ? = (+ Ulog, () -> Float) in let (()) = (()) in 0.001536|}, + ), + skip_menhir_maketerm_equivalent_test( + "Sum in product in typeap", + {|((fun _ -> b)) @< [(+ Kfgii, Float)] >|}, + ), + skip_menhir_maketerm_equivalent_test( + "Non-unique constructors currently throws in equality", + {|type ? = ((+ ? + ?)) in []|}, ), - // QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), + QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), // Disabled due to bugs in ExpToSegment // e.g. https://github.com/hazelgrove/hazel/issues/1445 // QCheck_alcotest.to_alcotest(qcheck_menhir_serialized_equivalent_test), From d8bf5e1ac91dfb0a3ec05a2f45bd92b4afededea Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:24:57 -0500 Subject: [PATCH 198/281] Commenting out skipped tests because of bug in Junit_alcotest --- test/Test_Menhir.re | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 79d59187c8..58df6d0151 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -997,27 +997,27 @@ let ex5 = list_of_mylist(x) in |}, ), // This fails because MakeTerm can't handle left to right keyword prefixes. - skip_menhir_maketerm_equivalent_test( - "Prefixed keyword parses", - {|let ? = ina in ?|}, - ), - // Menhir is doing the skipped better than MakeTerm - skip_menhir_maketerm_equivalent_test( - "Prefixed keyword parses", - {|type ? = rec ? -> + Aramj -> Bool in ?|}, - ), - skip_menhir_maketerm_equivalent_test( - "List concat and typap", - {|type ? = (+ Ulog, () -> Float) in let (()) = (()) in 0.001536|}, - ), - skip_menhir_maketerm_equivalent_test( - "Sum in product in typeap", - {|((fun _ -> b)) @< [(+ Kfgii, Float)] >|}, - ), - skip_menhir_maketerm_equivalent_test( - "Non-unique constructors currently throws in equality", - {|type ? = ((+ ? + ?)) in []|}, - ), + // skip_menhir_maketerm_equivalent_test( + // "Prefixed keyword parses", + // {|let ? = ina in ?|}, + // ), + // // Menhir is doing the skipped better than MakeTerm + // skip_menhir_maketerm_equivalent_test( + // "Prefixed keyword parses", + // {|type ? = rec ? -> + Aramj -> Bool in ?|}, + // ), + // skip_menhir_maketerm_equivalent_test( + // "List concat and typap", + // {|type ? = (+ Ulog, () -> Float) in let (()) = (()) in 0.001536|}, + // ), + // skip_menhir_maketerm_equivalent_test( + // "Sum in product in typeap", + // {|((fun _ -> b)) @< [(+ Kfgii, Float)] >|}, + // ), + // skip_menhir_maketerm_equivalent_test( + // "Non-unique constructors currently throws in equality", + // {|type ? = ((+ ? + ?)) in []|}, + // ), QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), // Disabled due to bugs in ExpToSegment // e.g. https://github.com/hazelgrove/hazel/issues/1445 From 56b3291399574cd5cd99eadff424af9551b56533 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:26:05 -0500 Subject: [PATCH 199/281] Remove unused basic_reference.txt --- basic_reference.txt | 118 -------------------------------------------- 1 file changed, 118 deletions(-) delete mode 100644 basic_reference.txt diff --git a/basic_reference.txt b/basic_reference.txt deleted file mode 100644 index 8c3ae8ad0a..0000000000 --- a/basic_reference.txt +++ /dev/null @@ -1,118 +0,0 @@ - - - -let empty_hole = ? in - - - -let non_empty_hole : Int = true in - - -let bool: Bool = true in -let operators = !true && false || true in -let conditional = if !true then 1 else 2 in - - -let num: Int = 1 in -let arithmetic = -num*1 + 2/3 - 4**5 in -let comparison = -(0 == 0, 0 < 1, 1 <= 1, 2 > 1, 1 >= 1) -in - - -let float: Float = 0.1 in -let artihmetic = 0. *. 1. +. 2. /. 3. -. 4. **. 5. in -let comparison = -(0. ==. 0., 0. <. 1., 1. <=. 1., 2. >. 1., 1. >=. 1.) -in - - -let string = "Hello, world!" in -let concatenation = string ++ " Goodbye." in -let comparison = string$== "Hello, world!" in - - -let tuple : (Int, Bool, (Bool, Int)) = -(1, true, (false, 3)) in -let (a, b, (c, d)) = tuple in - - -let y : (Int, Int, Int) -> Int = -fun (m, x, b) -> m * x + b in - - -let double_recursively : Int -> Int = -fun n -> -if n == 0 -then 0 -else double_recursively(n - 1) + 2 -in - - -let (even : Int -> Bool, odd : Int -> Bool) = -(fun n -> if n == 0 then true else odd(n - 1), -fun n -> if n == 0 then false else even(n - 1)) -in - - -let empty_list : [Int] = [] in -let non_empty_list : [Int] = 1::2::3::[] in -let list_literals : [Int] = [1, 2, 3] in -let length : [Int] -> Int = -fun xs -> -case xs -| [] => 0 -| hd::tl => 1 + length(tl) -end -in -let has_at_least_two_elements : [Int] -> Bool = -fun xs -> -case xs -| [] => false -| hd::[] => false -| a::b::[] => true -end -in - - -type Exp = -+ Var(String) -+ Lam(String, Exp) -+ Ap(Exp, Exp) in -let exp_equal: (Exp, Exp) -> Bool = -fun es -> -case es -| Var(x), Var(y) => x$== y -| Lam(x1, e1), Lam(x2, e2) => -x1$== x2 && exp_equal(e1, e2) -| Ap(e1, e2), Ap(e3, e4) => -exp_equal(e1, e3) && exp_equal(e2, e4) -| _ => false -end -in - - -let poly_id: forall a -> a -> a = -typfun a -> fun x : a -> x -in -let apply_both: -forall a -> forall b -> (forall c -> c -> c) -> ((a, b) -> (a, b)) = -typfun a -> typfun b -> -fun f : forall c -> (c -> c) -> -fun (x, y) : (a, b) -> (f@(x), f@(y)) -in -let list_length: forall a -> [a] -> Int = -typfun a -> fun l : [a] -> -case l -| [] => 0 -| hd::tl => 1 + list_length@(tl) -end -in - - -test 2 + 2 == 4 end; -test 3 + 3 == 6 end; -test 2 + 2 == 5 end; - - -2 + 2 From 30e0af4773d6aeef91248790bf2026257879c601 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:27:12 -0500 Subject: [PATCH 200/281] Revert pp formatting for id tagged --- src/haz3lcore/lang/term/IdTagged.re | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/haz3lcore/lang/term/IdTagged.re b/src/haz3lcore/lang/term/IdTagged.re index 3bf449633e..200be8a4ab 100644 --- a/src/haz3lcore/lang/term/IdTagged.re +++ b/src/haz3lcore/lang/term/IdTagged.re @@ -15,10 +15,10 @@ type t('a) = { }; // To be used if you want to remove the id from the debug output -let pp: ((Format.formatter, 'a) => unit, Format.formatter, t('a)) => unit = - (fmt_a, formatter, ta) => { - fmt_a(formatter, ta.term); - }; +// let pp: ((Format.formatter, 'a) => unit, Format.formatter, t('a)) => unit = +// (fmt_a, formatter, ta) => { +// fmt_a(formatter, ta.term); +// }; let fresh = term => { {ids: [Id.mk()], copied: false, term}; }; From 896224d9abfa3d2b1ed5b66071b00f366776108c Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:28:17 -0500 Subject: [PATCH 201/281] revert formatting change --- src/haz3lcore/statics/Elaborator.re | 1 - 1 file changed, 1 deletion(-) diff --git a/src/haz3lcore/statics/Elaborator.re b/src/haz3lcore/statics/Elaborator.re index cb48b35d63..979a2128c8 100644 --- a/src/haz3lcore/statics/Elaborator.re +++ b/src/haz3lcore/statics/Elaborator.re @@ -207,7 +207,6 @@ let rec elaborate = (m: Statics.Map.t, uexp: UExp.t): (DHExp.t, Typ.t) => { let (elaborated_type, ctx, co_ctx) = elaborated_type(m, uexp); let cast_from = (ty, exp) => fresh_cast(exp, ty, elaborated_type); let (term, rewrap) = UExp.unwrap(uexp); - let dhexp = switch (term) { | Invalid(_) From 3b3087b96db79b1680534f4371d4a575782671f3 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:33:28 -0500 Subject: [PATCH 202/281] Revert formatting change --- src/haz3lweb/util/SvgUtil.re | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/src/haz3lweb/util/SvgUtil.re b/src/haz3lweb/util/SvgUtil.re index 0b28cf9836..5809f70432 100644 --- a/src/haz3lweb/util/SvgUtil.re +++ b/src/haz3lweb/util/SvgUtil.re @@ -285,18 +285,10 @@ module OrthogonalPolygon = { let min_max = Point.{x: min.x, y: max_y}; let max_min = Point.{x: max_x, y: min.y}; [ - { - // left sides point in negative direction - src: min_max, - dst: min, - next: None, - }, - { - // right sides point in positive direction - src: max_min, - dst: max, - next: None, - }, + // left sides point in negative direction + {src: min_max, dst: min, next: None}, + // right sides point in positive direction + {src: max_min, dst: max, next: None}, ]; }) |> List.flatten From 6f38eb655fde38634b68a46fde59f83882595653 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:38:50 -0500 Subject: [PATCH 203/281] Revert term base to dev --- src/haz3lcore/statics/TermBase.re | 74 ++++++++++++++----------------- 1 file changed, 33 insertions(+), 41 deletions(-) diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index 03d6354620..e8c4b339f3 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -46,8 +46,6 @@ type deferral_position_t = the id of the closure. */ -//Comments represent the textual syntax of each term for use in the menhir parser -//e = exp, ty = typ, tp = tpat, p = pat, s = string, x = ident [@deriving (show({with_path: false}), sexp, yojson)] type any_t = | Exp(exp_t) @@ -58,52 +56,46 @@ type any_t = | Nul(unit) | Any(unit) and exp_term = - | Invalid(string) //? s - | EmptyHole //? + | Invalid(string) + | EmptyHole | MultiHole(list(any_t)) - | DynamicErrorHole(exp_t, InvalidOperationError.t) //This exp takes in the Sexp serialization of the InvalidOperationError.t as a string (s); // <> - | FailedCast(exp_t, typ_t, typ_t) // e ? ty2> - | Deferral(deferral_position_t) /*InAp _*/ /*OutAp _*/ - | Undefined //undef - | Bool(bool) //false - | Int(int) //1 - | Float(float) //1.0 - | String(string) //"hi" - | ListLit(list(exp_t)) //[e1, e2, ...] - | Constructor(string, typ_t) // Typ.t field is only meaningful in dynamic expressions /*capitalized ident*/ //X: ty + | DynamicErrorHole(exp_t, InvalidOperationError.t) + | FailedCast(exp_t, typ_t, typ_t) + | Deferral(deferral_position_t) + | Undefined + | Bool(bool) + | Int(int) + | Float(float) + | String(string) + | ListLit(list(exp_t)) + | Constructor(string, typ_t) // Typ.t field is only meaningful in dynamic expressions | Fun( pat_t, exp_t, [@show.opaque] option(closure_environment_t), option(Var.t), - ) //fun p -> e1 opt(x) - | TypFun(tpat_t, exp_t, option(Var.t)) //typfun tp -> e - | Tuple(list(exp_t)) //(e1, e2) - | Var(Var.t) //x - | Let(pat_t, exp_t, exp_t) //let p = e1 in e2 - | FixF(pat_t, exp_t, option(closure_environment_t)) //fix p -> e - | TyAlias(tpat_t, typ_t, exp_t) //type tp = ty in e - | Ap(Operators.ap_direction, exp_t, exp_t) //e1(e2) - | TypAp(exp_t, typ_t) /*e @ */ - | DeferredAp(exp_t, list(exp_t)) //e1(e2, _, e3) - | If(exp_t, exp_t, exp_t) //if e1 then e2 else e3 - | Seq(exp_t, exp_t) //e1; e2 - | Test(exp_t) //test e end - | Filter(stepper_filter_kind_t, exp_t) /*let act represent filter action*/ //act e1 e2 - | Closure([@show.opaque] closure_environment_t, exp_t) // menhir - spoke with cyrus we don't need closures in the menhir - | Parens(exp_t) // (e) - | Cons(exp_t, exp_t) //e1 :: e2 - | ListConcat(exp_t, exp_t) //e1 @ e2 - | UnOp(Operators.op_un, exp_t) //!e -e $e - | BinOp(Operators.op_bin, exp_t, exp_t) //e1 + e2 - | BuiltinFun(string) //builtin(e1) + ) + | TypFun(tpat_t, exp_t, option(Var.t)) + | Tuple(list(exp_t)) + | Var(Var.t) + | Let(pat_t, exp_t, exp_t) + | FixF(pat_t, exp_t, option(closure_environment_t)) + | TyAlias(tpat_t, typ_t, exp_t) + | Ap(Operators.ap_direction, exp_t, exp_t) + | TypAp(exp_t, typ_t) + | DeferredAp(exp_t, list(exp_t)) + | If(exp_t, exp_t, exp_t) + | Seq(exp_t, exp_t) + | Test(exp_t) + | Filter(stepper_filter_kind_t, exp_t) + | Closure([@show.opaque] closure_environment_t, exp_t) + | Parens(exp_t) // ( + | Cons(exp_t, exp_t) + | ListConcat(exp_t, exp_t) + | UnOp(Operators.op_un, exp_t) + | BinOp(Operators.op_bin, exp_t, exp_t) + | BuiltinFun(string) | Match(exp_t, list((pat_t, exp_t))) - /* - case e1 - | p1 => e2 - | p2 => e3 - end - */ /* INVARIANT: in dynamic expressions, casts must be between two consistent types. Both types should be normalized in dynamics for the cast calculus to work right. */ From ad9ddfa2a9610cd2daaeee76d306f5ea0d493f82 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 15:53:28 -0500 Subject: [PATCH 204/281] Remove debug statements --- test/Test_Menhir.re | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 58df6d0151..83d9da9e4b 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -248,7 +248,7 @@ let i = ref(0); let qcheck_menhir_maketerm_equivalent_test = QCheck.Test.make( ~name="Menhir and maketerm are equivalent", - ~count=100, + ~count=1000, QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(7)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); @@ -301,16 +301,11 @@ let qcheck_menhir_maketerm_equivalent_test = ); let serialized = Printer.of_segment(~holes=Some("?"), segment); - print_endline("Serialized: " ++ serialized); let make_term_parsed = make_term_parse(serialized); let menhir_parsed = Haz3lmenhir.Interface.parse_program(serialized); let menhir_parsed_converted = Haz3lmenhir.Conversion.Exp.of_menhir_ast(menhir_parsed); - print_endline("MakeTerm: " ++ DHExp.show(make_term_parsed)); - print_endline( - "Menhir parsed: " ++ DHExp.show(menhir_parsed_converted), - ); switch ( Haz3lcore.DHExp.fast_equal(make_term_parsed, menhir_parsed_converted) ) { @@ -361,9 +356,6 @@ let qcheck_menhir_serialized_equivalent_test = let serialized = Printer.of_segment(~holes=Some("?"), segment); let menhir_parsed = Haz3lmenhir.Interface.parse_program(serialized); - print_endline("Serialized: " ++ serialized); - print_endline("Menhir parsed: " ++ AST.show_exp(menhir_parsed)); - print_endline("Original" ++ AST.show_exp(exp)); menhir_parsed == exp; }, ); From 44caaa0230755953fcf9e459dc67253b7d42705c Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 16:04:39 -0500 Subject: [PATCH 205/281] Cleaning up tests --- test/Test_Menhir.re | 108 +++++++++++++------------------------------- 1 file changed, 32 insertions(+), 76 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 83d9da9e4b..fe12a51aa1 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -2,18 +2,12 @@ open Haz3lmenhir; open Alcotest; open Haz3lcore; -let testable_ast = testable(Fmt.using(AST.show_exp, Fmt.string), (==)); - -let ids = List.init(12, _ => Id.mk()); -let id_at = x => x |> List.nth(ids); - -let exp_typ = +let alco_check = testable( Fmt.using(Haz3lcore.Exp.show, Fmt.string), Haz3lcore.DHExp.fast_equal, - ); - -let alco_check = exp_typ |> Alcotest.check; + ) + |> Alcotest.check; let strip_parens = Exp.map_term( @@ -74,6 +68,7 @@ let skip_menhir_only_test = (name: string, _exp: Term.Exp.t, _actual: string) => let skip_menhir_maketerm_equivalent_test = (~speed_level=`Quick, name: string, _actual: string) => test_case(name, speed_level, () => {Alcotest.skip()}); + // TODO Assert against result instead of exception for parse failure for better error messages let parser_test = (name: string, exp: Term.Exp.t, actual: string) => test_case( @@ -101,64 +96,41 @@ let menhir_maketerm_equivalent_test = ) }); -let fun_exp: Exp.t = - Fun(Var("x") |> Pat.fresh, Var("x") |> Exp.fresh, None, None) |> Exp.fresh; - -//Test for a let function -let let_fun_uexp: Exp.t = - Let( - Var("f") |> Pat.fresh, - Fun(Var("x") |> Pat.fresh, Int(1) |> Exp.fresh, None, None) |> Exp.fresh, - Int(55) |> Exp.fresh, - ) - |> Exp.fresh; - -let let_fun_str = " +let let_fun_test = () => + parser_test( + "Let expression for a function which is not recursive (menhir)", + Let( + Var("f") |> Pat.fresh, + Fun(Var("x") |> Pat.fresh, Int(1) |> Exp.fresh, None, None) + |> Exp.fresh, + Int(55) |> Exp.fresh, + ) + |> Exp.fresh, + " let f = fun x -> 1 f in -55"; - -let let_fun_test = () => - parser_test( - "Let expression for a function which is not recursive (menhir)", - let_fun_uexp, - let_fun_str, +55", ); -//Test for an empty hole -let empty_hole_str = "?"; -let empty_hole_uexp: Exp.t = { - ids: [id_at(0)], - term: EmptyHole, - copied: false, -}; let empty_hole_test = () => - parser_test("Empty hole (menhir)", empty_hole_uexp, empty_hole_str); - -//Test for a free variable -let free_var_uexp: Exp.t = { - ids: [id_at(0)], - term: Parens({ids: [id_at(1)], term: Var("y"), copied: false}), - copied: false, -}; + parser_test("Empty hole (menhir)", EmptyHole |> Exp.fresh, "?"); + let free_var_test = () => parser_test( "Nonempty hole with free variable (menhir)", - free_var_uexp, + Parens(Var("y") |> Exp.fresh) |> Exp.fresh, "y", ); -//Menhir test for a binary operation -let bin_op_uexp: Exp.t = - BinOp(Int(Plus), Int(1) |> Exp.fresh, Int(2) |> Exp.fresh) |> Exp.fresh; - -let bin_op_str = "1 + 2"; - let bin_op_test = () => - parser_test("binary integer operation (plus)", bin_op_uexp, bin_op_str); + parser_test( + "binary integer operation (plus)", + BinOp(Int(Plus), Int(1) |> Exp.fresh, Int(2) |> Exp.fresh) |> Exp.fresh, + "1 + 2", + ); //Inconsistent branches menhir test let case_menhir_str = " @@ -201,28 +173,9 @@ let ap_fun_str = " let ap_fun_test = () => parser_test("Application of a function (menhir)", ap_fun_uexp, ap_fun_str); -//Consistent if statement menhir test -let consistent_if_uexp: Exp.t = - If(Bool(false) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) - |> Exp.fresh; - -let consistent_if_str = " - if false then 8 else 6 -"; -let consistent_if_menhir = () => - parser_test( - "Consistent case with rules (BoolLit(true), IntLit(8)) and (BoolLit(false), IntLit(6))", - consistent_if_uexp, - consistent_if_str, - ); - //Single integer menhir test let single_int_str = "8"; -let single_int_uexp: Exp.t = { - ids: [id_at(0)], - term: Int(8), - copied: false, -}; +let single_int_uexp: Exp.t = Int(8) |> Exp.fresh; let single_integer_menhir = () => parser_test( "Single integer test (menhir)", @@ -243,12 +196,10 @@ let menhir_doesnt_crash_test = (name, src) => }, ); -let i = ref(0); - let qcheck_menhir_maketerm_equivalent_test = QCheck.Test.make( ~name="Menhir and maketerm are equivalent", - ~count=1000, + ~count=100, QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(7)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); @@ -364,7 +315,12 @@ let tests = ( "MenhirParser", [ parser_test("Integer Literal", Int(8) |> Exp.fresh, "8"), - parser_test("Fun", fun_exp, "fun x -> x"), + parser_test( + "Fun", + Fun(Var("x") |> Pat.fresh, Var("x") |> Exp.fresh, None, None) + |> Exp.fresh, + "fun x -> x", + ), parser_test( "String Literal", String("Hello World") |> Exp.fresh, From 57de33c91c4ce3cfb9f2c8b21eb0b03f92e1a5df Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 16:10:46 -0500 Subject: [PATCH 206/281] More test cleanup --- test/Test_Menhir.re | 115 +++----------------------------------------- 1 file changed, 7 insertions(+), 108 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index fe12a51aa1..3390aefd34 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -9,7 +9,7 @@ let alco_check = ) |> Alcotest.check; -let strip_parens = +let strip_parens_and_add_builtins = Exp.map_term( ~f_exp= (cont: TermBase.exp_t => TermBase.exp_t, e: TermBase.exp_t) => @@ -44,7 +44,7 @@ let strip_parens = // Existing recovering parser let make_term_parse = (s: string) => - strip_parens( + strip_parens_and_add_builtins( MakeTerm.from_zip_for_sem(Option.get(Printer.zipper_of_string(s))).term, ); @@ -60,7 +60,6 @@ let menhir_matches = (exp: Term.Exp.t, actual: string) => let menhir_only_test = (name: string, exp: Term.Exp.t, actual: string) => test_case(name, `Quick, () => {menhir_matches(exp, actual)}); -// TODO Remove these before merge. Using it to mark skipped tests until we fix them. let skip_parser_test = (name: string, _exp: Term.Exp.t, _actual: string) => test_case(name, `Quick, () => {Alcotest.skip()}); let skip_menhir_only_test = (name: string, _exp: Term.Exp.t, _actual: string) => @@ -69,7 +68,6 @@ let skip_menhir_maketerm_equivalent_test = (~speed_level=`Quick, name: string, _actual: string) => test_case(name, speed_level, () => {Alcotest.skip()}); -// TODO Assert against result instead of exception for parse failure for better error messages let parser_test = (name: string, exp: Term.Exp.t, actual: string) => test_case( name, @@ -96,106 +94,6 @@ let menhir_maketerm_equivalent_test = ) }); -let let_fun_test = () => - parser_test( - "Let expression for a function which is not recursive (menhir)", - Let( - Var("f") |> Pat.fresh, - Fun(Var("x") |> Pat.fresh, Int(1) |> Exp.fresh, None, None) - |> Exp.fresh, - Int(55) |> Exp.fresh, - ) - |> Exp.fresh, - " -let f = - fun x -> - 1 - f - in -55", - ); - -let empty_hole_test = () => - parser_test("Empty hole (menhir)", EmptyHole |> Exp.fresh, "?"); - -let free_var_test = () => - parser_test( - "Nonempty hole with free variable (menhir)", - Parens(Var("y") |> Exp.fresh) |> Exp.fresh, - "y", - ); - -let bin_op_test = () => - parser_test( - "binary integer operation (plus)", - BinOp(Int(Plus), Int(1) |> Exp.fresh, Int(2) |> Exp.fresh) |> Exp.fresh, - "1 + 2", - ); - -//Inconsistent branches menhir test -let case_menhir_str = " - case 4 == 3 - | true => 24 - | false => 32 -end -"; -let case_uexp: Exp.t = - Match( - BinOp(Int(Equals), Int(4) |> Exp.fresh, Int(3) |> Exp.fresh) - |> Exp.fresh, - [ - (Bool(true) |> Pat.fresh, Int(24) |> Exp.fresh), - (Bool(false) |> Pat.fresh, Int(32) |> Exp.fresh), - ], - ) - |> Exp.fresh; -let inconsistent_case_test = () => - parser_test("Case test", case_uexp, case_menhir_str); - -//Function free var application menhir test -let ap_fun_uexp: Exp.t = - Ap( - Forward, - Fun( - Var("x") |> Pat.fresh, - BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) - |> Exp.fresh, - None, - None, - ) - |> Exp.fresh, - Var("y") |> Exp.fresh, - ) - |> Exp.fresh; -let ap_fun_str = " - (fun x -> 4 + 5)(y) -"; -let ap_fun_test = () => - parser_test("Application of a function (menhir)", ap_fun_uexp, ap_fun_str); - -//Single integer menhir test -let single_int_str = "8"; -let single_int_uexp: Exp.t = Int(8) |> Exp.fresh; -let single_integer_menhir = () => - parser_test( - "Single integer test (menhir)", - single_int_uexp, - single_int_str, - ); - -let menhir_doesnt_crash_test = (name, src) => - test_case( - name, - `Quick, - () => { - let _menhir_parsed = - Haz3lmenhir.Conversion.Exp.of_menhir_ast( - Haz3lmenhir.Interface.parse_program(src), - ); - (); - }, - ); - let qcheck_menhir_maketerm_equivalent_test = QCheck.Test.make( ~name="Menhir and maketerm are equivalent", @@ -324,7 +222,7 @@ let tests = ( parser_test( "String Literal", String("Hello World") |> Exp.fresh, - "\"Hello World\"", + {|"Hello World"|}, ), parser_test("Bool Literal", Bool(true) |> Exp.fresh, "true"), parser_test("Empty Hole", EmptyHole |> Exp.fresh, "?"), @@ -353,7 +251,7 @@ let tests = ( parser_test( "Tuple", Tuple([Int(4) |> Exp.fresh, Int(5) |> Exp.fresh]) |> Exp.fresh, - "(4, 5)" // TODO Verify with maketerm. Should this be parens or not + "(4, 5)", ), parser_test( "Match", @@ -609,7 +507,7 @@ let tests = ( "Pattern with type ascription", "fun (b : Bool) -> b", ), - menhir_only_test( + parser_test( "Type Hole in arrow cast", Fun( Cast( @@ -632,7 +530,7 @@ let tests = ( |> Exp.fresh, "fun (b : ? -> ?) -> ?", ), - menhir_only_test( + parser_test( "multiargument function", Ap( Forward, @@ -945,6 +843,7 @@ let ex5 = list_of_mylist(x) in |}, ), // This fails because MakeTerm can't handle left to right keyword prefixes. + // Skipped tests are commented out because of junit alcotest bug https://github.com/Khady/ocaml-junit/issues/9 // skip_menhir_maketerm_equivalent_test( // "Prefixed keyword parses", // {|let ? = ina in ?|}, From a7c80e93d571554d202f139cd1405eecaa97f98c Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 16:15:33 -0500 Subject: [PATCH 207/281] More cleanup --- test/Test_Menhir.re | 97 ++++++++++++++++++++------------------------- 1 file changed, 43 insertions(+), 54 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 3390aefd34..94ebac1864 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -60,15 +60,11 @@ let menhir_matches = (exp: Term.Exp.t, actual: string) => let menhir_only_test = (name: string, exp: Term.Exp.t, actual: string) => test_case(name, `Quick, () => {menhir_matches(exp, actual)}); -let skip_parser_test = (name: string, _exp: Term.Exp.t, _actual: string) => - test_case(name, `Quick, () => {Alcotest.skip()}); -let skip_menhir_only_test = (name: string, _exp: Term.Exp.t, _actual: string) => - test_case(name, `Quick, () => {Alcotest.skip()}); let skip_menhir_maketerm_equivalent_test = (~speed_level=`Quick, name: string, _actual: string) => test_case(name, speed_level, () => {Alcotest.skip()}); -let parser_test = (name: string, exp: Term.Exp.t, actual: string) => +let full_parser_test = (name: string, exp: Term.Exp.t, actual: string) => test_case( name, `Quick, @@ -94,6 +90,11 @@ let menhir_maketerm_equivalent_test = ) }); +/** + * QCheck Test to check the equivalence of the Menhir and MakeTerm parsing. + * We generate an expression, convert it to the core representation, convert it to a segment, + * serialize it, parse it with MakeTerm, and parse it with Menhir. + */ let qcheck_menhir_maketerm_equivalent_test = QCheck.Test.make( ~name="Menhir and maketerm are equivalent", @@ -167,8 +168,14 @@ let qcheck_menhir_maketerm_equivalent_test = }, ); -// TODO This fails due to types not being serialized on constructors -// We should do a pass before the equality check that removes the types on the constructors and check equality after +/** + * QCheck Test to check that menhir parses out what ExpToSegment serializes. + * We generate an expression, convert it to the core representation, convert it to a segment, + * serialize it, parse it with Menhir, and compare to the original. + * + * TODO This fails due to types not being serialized on constructors + * and some other ExpToSegment inconsistencies + */ let qcheck_menhir_serialized_equivalent_test = QCheck.Test.make( ~name="Menhir through ExpToSegment and back", @@ -177,22 +184,6 @@ let qcheck_menhir_serialized_equivalent_test = exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); - // TODO Maybe only do this when necessary. - // TODO Check with Matthew if I'm using this correctly - // Add parens around tuples - let core_exp = - Exp.map_term( - ~f_exp= - (cont, e) => - switch (e.term) { - | Tuple(es) => - Parens(Tuple(es |> List.map(cont)) |> Exp.fresh) - |> Exp.fresh - | _ => cont(e) - }, - core_exp, - ); - let segment = ExpToSegment.exp_to_segment( ~settings= @@ -212,33 +203,33 @@ let qcheck_menhir_serialized_equivalent_test = let tests = ( "MenhirParser", [ - parser_test("Integer Literal", Int(8) |> Exp.fresh, "8"), - parser_test( + full_parser_test("Integer Literal", Int(8) |> Exp.fresh, "8"), + full_parser_test( "Fun", Fun(Var("x") |> Pat.fresh, Var("x") |> Exp.fresh, None, None) |> Exp.fresh, "fun x -> x", ), - parser_test( + full_parser_test( "String Literal", String("Hello World") |> Exp.fresh, {|"Hello World"|}, ), - parser_test("Bool Literal", Bool(true) |> Exp.fresh, "true"), - parser_test("Empty Hole", EmptyHole |> Exp.fresh, "?"), - parser_test("Var", Var("x") |> Exp.fresh, "x"), - parser_test( + full_parser_test("Bool Literal", Bool(true) |> Exp.fresh, "true"), + full_parser_test("Empty Hole", EmptyHole |> Exp.fresh, "?"), + full_parser_test("Var", Var("x") |> Exp.fresh, "x"), + full_parser_test( "Parens", Parens(Var("y") |> Exp.fresh) |> Exp.fresh, "(y)", ), - parser_test( + full_parser_test( "BinOp", BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) |> Exp.fresh, "4 + 5", ), - parser_test( + full_parser_test( "Let", Let( Var("x") |> Pat.fresh, @@ -248,12 +239,12 @@ let tests = ( |> Exp.fresh, "let x = 5 in x", ), - parser_test( + full_parser_test( "Tuple", Tuple([Int(4) |> Exp.fresh, Int(5) |> Exp.fresh]) |> Exp.fresh, "(4, 5)", ), - parser_test( + full_parser_test( "Match", Match( Int(4) |> Exp.fresh, @@ -268,24 +259,24 @@ let tests = ( | _ => "world" end|}, ), - parser_test( + full_parser_test( "If", If(Bool(true) |> Exp.fresh, Int(8) |> Exp.fresh, Int(6) |> Exp.fresh) |> Exp.fresh, "if true then 8 else 6", ), - parser_test( + full_parser_test( "Deferred Ap", DeferredAp(Var("x") |> Exp.fresh, [Deferral(InAp) |> Exp.fresh]) |> Exp.fresh, "x(_)", ), - parser_test( + full_parser_test( "Cons", Cons(Int(1) |> Exp.fresh, ListLit([]) |> Exp.fresh) |> Exp.fresh, "1 :: []", ), - parser_test( + full_parser_test( "ListLit", ListLit([ Int(1) |> Exp.fresh, @@ -322,7 +313,7 @@ let tests = ( Constructor("A", Var("T") |> Typ.fresh) |> Exp.fresh, "A ~ T", ), - parser_test( + full_parser_test( "Type Variable", Let( Cast( @@ -337,13 +328,13 @@ let tests = ( |> Exp.fresh, "let x : T = ? in x", ), - parser_test( + full_parser_test( "Type Alias", TyAlias(Var("x") |> TPat.fresh, Int |> Typ.fresh, Int(1) |> Exp.fresh) |> Exp.fresh, "type x = Int in 1", ), - parser_test( + full_parser_test( "Test", Test( BinOp(Int(Equals), Int(3) |> Exp.fresh, Int(3) |> Exp.fresh) @@ -352,7 +343,7 @@ let tests = ( |> Exp.fresh, "test 3 == 3 end", ), - parser_test( + full_parser_test( "Filter", Filter( Filter({act: (Eval, All), pat: Int(3) |> Exp.fresh}), @@ -361,7 +352,7 @@ let tests = ( |> Exp.fresh, "eval 3 in 3" // TODO Use other filter commands ), - parser_test( + full_parser_test( "List Concat", ListConcat( ListLit([Int(1) |> Exp.fresh, Int(2) |> Exp.fresh]) |> Exp.fresh, @@ -370,7 +361,7 @@ let tests = ( |> Exp.fresh, "[1, 2] @ [3, 4]", ), - parser_test( + full_parser_test( "times and divide precendence", BinOp( Int(Divide), @@ -381,7 +372,7 @@ let tests = ( |> Exp.fresh, "1 * 2 / 3", ), - parser_test( + full_parser_test( "plus and minus precendence", BinOp( Int(Plus), @@ -392,7 +383,7 @@ let tests = ( |> Exp.fresh, "1 - 2 + 3", ), - parser_test( + full_parser_test( "Integer Ops", BinOp( Int(GreaterThanOrEqual), @@ -419,8 +410,8 @@ let tests = ( |> Exp.fresh, "-1 + 2 - 3 / 4 * 5 ** 6 >= 8", ), - parser_test("Float", Float(1.) |> Exp.fresh, "1."), - parser_test( + full_parser_test("Float", Float(1.) |> Exp.fresh, "1."), + full_parser_test( "Float Ops", BinOp( Float(LessThan), @@ -450,7 +441,7 @@ let tests = ( |> Exp.fresh, "2. -. 3. /. 4. *. 5. **. 6. <. 8.", ), - parser_test( + full_parser_test( "Let binding with type ascription", Let( Cast( @@ -477,7 +468,7 @@ let tests = ( |> Exp.fresh, "named_fun f x -> x + 5", ), - parser_test( + full_parser_test( "basic sum type", Let( Cast( @@ -507,7 +498,7 @@ let tests = ( "Pattern with type ascription", "fun (b : Bool) -> b", ), - parser_test( + full_parser_test( "Type Hole in arrow cast", Fun( Cast( @@ -530,7 +521,7 @@ let tests = ( |> Exp.fresh, "fun (b : ? -> ?) -> ?", ), - parser_test( + full_parser_test( "multiargument function", Ap( Forward, @@ -669,8 +660,6 @@ test 2 + 2 == 5 end; 2 + 2 |}, ), - // TODO This is an issue with `int_of_float` being parsed - // as a builtin function in menhir and a Var in MakeTerm menhir_maketerm_equivalent_test( ~speed_level=`Slow, "Altered Documentation Buffer: Projectors", From 57b0a1d25d77d104df1dd9cd266b674dcb2af33c Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 16:24:05 -0500 Subject: [PATCH 208/281] Address todos in Conversion --- src/haz3lmenhir/Conversion.re | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index dc481e951e..650c9b91af 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -343,15 +343,15 @@ module rec Exp: { Sexplib.Sexp.to_string(Haz3lcore.InvalidOperationError.sexp_of_t(s)), ) | Deferral(_) => Deferral - | Filter(_) => raise(Failure("Filter not supported")) // TODO - | MultiHole(_) => raise(Failure("MultiHole not supported")) // TODO - | Closure(_) => raise(Failure("Closure not supported")) // TODO + | Filter(Residue(_), _) => raise(Failure("Residue not supported")) + | MultiHole(_) => raise(Failure("MultiHole not supported")) + | Closure(_) => raise(Failure("Closure not supported")) | Parens(e) => of_core(e) | Constructor(s, typ) => Constructor(s, Typ.of_core(typ)) | DeferredAp(e, es) => ApExp(of_core(e), TupleExp(List.map(of_core, es))) | Fun(p, e, _, name_opt) => Fun(Pat.of_core(p), of_core(e), name_opt) - | Ap(Reverse, _, _) => raise(Failure("Reverse not supported")) // TODO + | Ap(Reverse, _, _) => raise(Failure("Reverse not supported")) }; }; } @@ -429,8 +429,20 @@ and Typ: { | Forall(tp, t) => ForallType(TPat.of_core(tp), of_core(t)) | Rec(tp, t) => RecType(TPat.of_core(tp), of_core(t)) | Parens(t) => of_core(t) - | Ap(_) => raise(Failure("Ap not supported")) // TODO - | Sum(_) => raise(Failure("Sum not supported")) // TODO + | Ap(_) => raise(Failure("Ap not supported")) + | Sum(constructors) => + let sumterms = + List.map( + (variant: Haz3lcore.ConstructorMap.variant(Haz3lcore.Typ.t)): AST.sumterm => { + switch (variant) { + | Variant(name, _, None) => Variant(name, None) + | Variant(name, _, Some(t)) => Variant(name, Some(of_core(t))) + | BadEntry(t) => BadEntry(of_core(t)) + } + }, + constructors, + ); + SumTyp(sumterms); }; }; } From ebe938072933e7046884255ed43b80c8cdfd4e4a Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 16:25:30 -0500 Subject: [PATCH 209/281] Rename binop --- src/haz3lmenhir/AST.re | 7 +++---- src/haz3lmenhir/Conversion.re | 4 ++-- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 006bce897a..0904525f4e 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -47,9 +47,8 @@ type op_bin_string = | Concat | Equals; -// TODO Rename to match others [@deriving (show({with_path: false}), sexp, qcheck, eq)] -type binOp = +type bin_op = | IntOp(op_bin_int) | FloatOp(op_bin_float) | StringOp(op_bin_string) @@ -147,7 +146,7 @@ type exp = | String(string) | ListExp(list(exp)) | TupleExp(list(exp)) - | BinExp(exp, binOp, exp) + | BinExp(exp, bin_op, exp) | UnOp(op_un, exp) | Let(pat, exp, exp) | Fun(pat, exp, option(string)) @@ -338,7 +337,7 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => ), Gen.map3( (op, e1, e2) => BinExp(e1, op, e2), - gen_binOp, + gen_bin_op, self((n - 1) / 2), self((n - 1) / 2), ), diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 650c9b91af..87c435674f 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -49,7 +49,7 @@ module Operators = { }; }; - let of_core_op_bin = (op: op_bin): AST.binOp => { + let of_core_op_bin = (op: op_bin): AST.bin_op => { switch (op) { | Int(op_int) => IntOp( @@ -174,7 +174,7 @@ module Operators = { }; [@deriving (show({with_path: false}), sexp, yojson)] - let of_menhir_ast = (op: AST.binOp): op_bin => { + let of_menhir_ast = (op: AST.bin_op): op_bin => { switch (op) { | IntOp(op_int) => Int(int_op_of_menhir_ast(op_int)) | FloatOp(op_float) => Float(float_op_of_menhir_ast(op_float)) From dd4dffa58d2f4ae32141ae25627c623e906ae219 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 16:26:16 -0500 Subject: [PATCH 210/281] Adjust comment --- src/haz3lmenhir/AST.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 0904525f4e..44bb036685 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -119,7 +119,7 @@ type pat = | ConsPat(pat, pat) | ListPat(list(pat)) | ApPat(pat, pat) - | InvalidPat(string); // TODO Menhir parser doesn't actually support invalid pats + | InvalidPat(string); // Menhir parser doesn't actually support invalid pats [@deriving (show({with_path: false}), sexp, qcheck, eq)] type if_consistency = From db049476f4bef26f7361838c9d50cb730a5b93e1 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Fri, 20 Dec 2024 16:28:09 -0500 Subject: [PATCH 211/281] Remove todo --- src/haz3lmenhir/Conversion.re | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index 87c435674f..a4311c5554 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -467,7 +467,7 @@ and TPat: { | EmptyHole => EmptyHoleTPat | Var(x) => VarTPat(x) | Invalid(i) => InvalidTPat(i) - | MultiHole(_) => raise(Failure("MultiHole not supported")) // TODO + | MultiHole(_) => raise(Failure("MultiHole not supported")) }; }; } @@ -514,7 +514,7 @@ and Pat: { | Ap(p1, p2) => ApPat(of_core(p1), of_core(p2)) | EmptyHole => EmptyHolePat | Wild => WildPat - | MultiHole(_) => raise(Failure("MultiHole not supported")) // TODO + | MultiHole(_) => raise(Failure("MultiHole not supported")) | Cast(p, t1, t2) => CastPat(of_core(p), Typ.of_core(t1), Typ.of_core(t2)) | Parens(p) => of_core(p) From 5cdb818aa1634e8c072f59473ee75bc1cf6f4438 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 11:10:59 -0500 Subject: [PATCH 212/281] Simplify qualified imports --- src/haz3lmenhir/AST.re | 114 +++++++++++++++++++++-------------------- 1 file changed, 59 insertions(+), 55 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 44bb036685..d0bba3be28 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -282,34 +282,34 @@ let gen_tpat = ); let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => - QCheck.( + QCheck.Gen.( let leaf = oneof([ - arb_int, - arb_str_exp, - arb_float, - arb_var, + arb_int.gen, + arb_str_exp.gen, + arb_float.gen, + arb_var.gen, map(x => Bool(x), bool), - always(~print=show_exp, EmptyHole), - always(~print=show_exp, TupleExp([])), - always(~print=show_exp, ListExp([])), + pure(EmptyHole), + pure(TupleExp([])), + pure(ListExp([])), ]); - let gen: Gen.t(exp) = + let gen: t(exp) = QCheck.Gen.fix( - (self: int => Gen.t(exp), n) => { + (self: int => t(exp), n) => { switch (n) { | 0 - | 1 => leaf.gen + | 1 => leaf | _ => - Gen.oneof([ - leaf.gen, - Gen.join( - Gen.map( + oneof([ + leaf, + join( + map( (sizes: array(int)) => { let exps = Array.map((size: int) => self(size), sizes); - let flattened = Gen.flatten_a(exps); - Gen.map( + let flattened = flatten_a(exps); + map( (exps: array(exp)) => ListExp(Array.to_list(exps)), flattened, ); @@ -317,12 +317,12 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => sized_arr(n), ), ), - Gen.join( - Gen.map( + join( + map( (sizes: array(int)) => { let exps = Array.map((size: int) => self(size), sizes); - let flattened = Gen.flatten_a(exps); - Gen.map( + let flattened = flatten_a(exps); + map( (exps: array(exp)) => TupleExp(Array.to_list(exps)), // TODO See if there's a way to do unit and various sizes here flattened, ); @@ -330,36 +330,36 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => non_single_element_arr(n), ), ), - Gen.map(exp => Test(exp), self(n - 1)), - Gen.map( + map(exp => Test(exp), self(n - 1)), + map( name => Constructor(name, UnknownType(Internal)), // TODO Ignoring typ because we don't serialize those in ExpToSegment arb_constructor_ident.gen, ), - Gen.map3( + map3( (op, e1, e2) => BinExp(e1, op, e2), gen_bin_op, self((n - 1) / 2), self((n - 1) / 2), ), - // Gen.map2((op, e) => UnOp(op, e), gen_op_un, self(n - 1)), // TODO ExpToSegment broken for UnOp - Gen.map3( + // map2((op, e) => UnOp(op, e), gen_op_un, self(n - 1)), // TODO ExpToSegment broken for UnOp + map3( (e1, e2, e3) => If(e1, e2, e3), self((n - 1) / 3), self((n - 1) / 3), self((n - 1) / 3), ), - Gen.map3( + map3( (p, e1, e2) => Let(p, e1, e2), gen_pat_sized((n - 1) / 3), self((n - 1) / 3), self((n - 1) / 3), ), - Gen.map2( + map2( (p, e): exp => Fun(p, e, None), gen_pat_sized((n - 1) / 2), self((n - 1) / 2), ), - Gen.( + { let e = self(n - 1 / 2); let case = n => { let p = gen_pat_sized(n / 2); @@ -371,7 +371,7 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => sized_arr(n - 1 / 2) >>= ( sizes => { - let cases: QCheck.Gen.t(array((pat, exp))) = + let cases: t(array((pat, exp))) = flatten_a(Array.map(case, sizes)); cases; } @@ -381,54 +381,58 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => ((e, cases)) => { CaseExp(e, Array.to_list(cases)); } - ) - ), - Gen.map2( + ); + }, + map2( (e1, e2) => ApExp(e1, e2), self((n - 1) / 2), - Gen.frequency([ + frequency([ (5, self((n - 1) / 2)), - (1, Gen.return(Deferral)), + (1, return(Deferral)), ]), ), - Gen.map2( + map2( (p, e) => FixF(p, e), gen_pat_sized((n - 1) / 2), self((n - 1) / 2), ), - Gen.( + { let* fa = gen_filter_action; let* e1 = self(n - 1); let+ e2 = self(n - 1); - Filter(fa, e1, e2) - ), - Gen.( + Filter(fa, e1, e2); + }, + { let* e1 = self((n - 1) / 2); let+ e2 = self((n - 1) / 2); - Seq(e1, e2) - ), - Gen.( + Seq(e1, e2); + }, + { let* e1 = self((n - 1) / 2); let+ e2 = self((n - 1) / 2); - Cons(e1, e2) - ), - Gen.( + Cons(e1, e2); + }, + { let* e1 = self((n - 1) / 2); let+ e2 = self((n - 1) / 2); - ListConcat(e1, e2) - ), - Gen.(let* tp = gen_tpat; let+ e = self(n - 1); TypFun(tp, e)), - Gen.( + ListConcat(e1, e2); + }, + { + let* tp = gen_tpat; + let+ e = self(n - 1); + TypFun(tp, e); + }, + { let* t = gen_typ_sized((n - 1) / 2); let+ e = self((n - 1) / 2); - TypAp(e, t) - ), - Gen.( + TypAp(e, t); + }, + { let* tp = gen_tpat; let* t = gen_typ_sized((n - 1) / 2); let+ e = self((n - 1) / 2); - TyAlias(tp, t, e) - ), + TyAlias(tp, t, e); + }, ]) } }, From d220808a803a45dae60e8d26b2d5af9a7254eefe Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 11:31:47 -0500 Subject: [PATCH 213/281] Refactor gen_exp_sized to use let* for improved readability and structure --- src/haz3lmenhir/AST.re | 116 ++++++++++++++++++++++------------------- 1 file changed, 61 insertions(+), 55 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index d0bba3be28..63e1b05760 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -304,61 +304,67 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => | _ => oneof([ leaf, - join( - map( - (sizes: array(int)) => { - let exps = Array.map((size: int) => self(size), sizes); - let flattened = flatten_a(exps); - map( - (exps: array(exp)) => ListExp(Array.to_list(exps)), - flattened, - ); - }, - sized_arr(n), - ), - ), - join( - map( - (sizes: array(int)) => { - let exps = Array.map((size: int) => self(size), sizes); - let flattened = flatten_a(exps); - map( - (exps: array(exp)) => TupleExp(Array.to_list(exps)), // TODO See if there's a way to do unit and various sizes here - flattened, - ); - }, - non_single_element_arr(n), - ), - ), - map(exp => Test(exp), self(n - 1)), - map( - name => Constructor(name, UnknownType(Internal)), // TODO Ignoring typ because we don't serialize those in ExpToSegment - arb_constructor_ident.gen, - ), - map3( - (op, e1, e2) => BinExp(e1, op, e2), - gen_bin_op, - self((n - 1) / 2), - self((n - 1) / 2), - ), - // map2((op, e) => UnOp(op, e), gen_op_un, self(n - 1)), // TODO ExpToSegment broken for UnOp - map3( - (e1, e2, e3) => If(e1, e2, e3), - self((n - 1) / 3), - self((n - 1) / 3), - self((n - 1) / 3), - ), - map3( - (p, e1, e2) => Let(p, e1, e2), - gen_pat_sized((n - 1) / 3), - self((n - 1) / 3), - self((n - 1) / 3), - ), - map2( - (p, e): exp => Fun(p, e, None), - gen_pat_sized((n - 1) / 2), - self((n - 1) / 2), - ), + { + let* sizes = sized_arr(n); + let+ exps = + flatten_a(Array.map((size: int) => self(size), sizes)); + ListExp(Array.to_list(exps)); + }, + { + let* sizes = non_single_element_arr(n); + let+ exps = + flatten_a(Array.map((size: int) => self(size), sizes)); + TupleExp(Array.to_list(exps)); + }, + { + let+ inner = self(n - 1); + Test(inner); + }, + { + let+ name = arb_constructor_ident.gen; + Constructor(name, UnknownType(Internal)); + }, + { + let* op = gen_bin_op; + let* e1 = self((n - 1) / 2); + let+ e2 = self((n - 1) / 2); + BinExp(e1, op, e2); + }, + { + // TODO ExpToSegment broken for UnOp + // { + // let* op = gen_op_un; + // let+ e = self((n - 1) / 2); + // UnOp(op, e); + // }, + + let* e1 = self((n - 1) / 3); + let* e2 = self((n - 1) / 3); + let+ e3 = self((n - 1) / 3); + If(e1, e2, e3); + }, + { + let* p = gen_pat_sized((n - 1) / 3); + let* e1 = self((n - 1) / 3); + let+ e2 = self((n - 1) / 3); + Let(p, e1, e2); + }, + { + let* p = gen_pat_sized((n - 1) / 2); + let+ e = self((n - 1) / 2); + Fun(p, e, None); + }, + { + let case = n => { + let p = gen_pat_sized(n / 2); + let e = self(n / 2); + tup2(p, e); + }; + let* e = self(n - 1 / 2); + let* sizes = sized_arr(n - 1 / 2); + let+ cases = flatten_a(Array.map(case, sizes)); + CaseExp(e, Array.to_list(cases)); + }, { let e = self(n - 1 / 2); let case = n => { From 423d874cca7f495bcff3aaa98b416150cd9f127d Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 11:42:58 -0500 Subject: [PATCH 214/281] Finish converting gen_exp to let notation --- src/haz3lmenhir/AST.re | 47 +++++++++++------------------------------- 1 file changed, 12 insertions(+), 35 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 63e1b05760..828423b996 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -366,42 +366,19 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => CaseExp(e, Array.to_list(cases)); }, { - let e = self(n - 1 / 2); - let case = n => { - let p = gen_pat_sized(n / 2); - let e = self(n / 2); - tup2(p, e); - }; - - let cases = - sized_arr(n - 1 / 2) - >>= ( - sizes => { - let cases: t(array((pat, exp))) = - flatten_a(Array.map(case, sizes)); - cases; - } - ); - tup2(e, cases) - >|= ( - ((e, cases)) => { - CaseExp(e, Array.to_list(cases)); - } - ); + let* e1 = self((n - 1) / 2); + let+ e2 = + frequency([ + (5, self((n - 1) / 2)), + (1, return(Deferral)), + ]); + ApExp(e1, e2); + }, + { + let* p = gen_pat_sized((n - 1) / 2); + let+ e = self((n - 1) / 2); + FixF(p, e); }, - map2( - (e1, e2) => ApExp(e1, e2), - self((n - 1) / 2), - frequency([ - (5, self((n - 1) / 2)), - (1, return(Deferral)), - ]), - ), - map2( - (p, e) => FixF(p, e), - gen_pat_sized((n - 1) / 2), - self((n - 1) / 2), - ), { let* fa = gen_filter_action; let* e1 = self(n - 1); From 8deebf7b292bffe6b0c093539a6796d01058d395 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 11:46:12 -0500 Subject: [PATCH 215/281] Refmt --- src/haz3lmenhir/AST.re | 254 ++++++++++++++++++++--------------------- 1 file changed, 125 insertions(+), 129 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 828423b996..07d006578e 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -294,135 +294,131 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => pure(TupleExp([])), pure(ListExp([])), ]); - - let gen: t(exp) = - QCheck.Gen.fix( - (self: int => t(exp), n) => { - switch (n) { - | 0 - | 1 => leaf - | _ => - oneof([ - leaf, - { - let* sizes = sized_arr(n); - let+ exps = - flatten_a(Array.map((size: int) => self(size), sizes)); - ListExp(Array.to_list(exps)); - }, - { - let* sizes = non_single_element_arr(n); - let+ exps = - flatten_a(Array.map((size: int) => self(size), sizes)); - TupleExp(Array.to_list(exps)); - }, - { - let+ inner = self(n - 1); - Test(inner); - }, - { - let+ name = arb_constructor_ident.gen; - Constructor(name, UnknownType(Internal)); - }, - { - let* op = gen_bin_op; - let* e1 = self((n - 1) / 2); - let+ e2 = self((n - 1) / 2); - BinExp(e1, op, e2); - }, - { - // TODO ExpToSegment broken for UnOp - // { - // let* op = gen_op_un; - // let+ e = self((n - 1) / 2); - // UnOp(op, e); - // }, - - let* e1 = self((n - 1) / 3); - let* e2 = self((n - 1) / 3); - let+ e3 = self((n - 1) / 3); - If(e1, e2, e3); - }, - { - let* p = gen_pat_sized((n - 1) / 3); - let* e1 = self((n - 1) / 3); - let+ e2 = self((n - 1) / 3); - Let(p, e1, e2); - }, - { - let* p = gen_pat_sized((n - 1) / 2); - let+ e = self((n - 1) / 2); - Fun(p, e, None); - }, - { - let case = n => { - let p = gen_pat_sized(n / 2); - let e = self(n / 2); - tup2(p, e); - }; - let* e = self(n - 1 / 2); - let* sizes = sized_arr(n - 1 / 2); - let+ cases = flatten_a(Array.map(case, sizes)); - CaseExp(e, Array.to_list(cases)); - }, - { - let* e1 = self((n - 1) / 2); - let+ e2 = - frequency([ - (5, self((n - 1) / 2)), - (1, return(Deferral)), - ]); - ApExp(e1, e2); - }, - { - let* p = gen_pat_sized((n - 1) / 2); - let+ e = self((n - 1) / 2); - FixF(p, e); - }, - { - let* fa = gen_filter_action; - let* e1 = self(n - 1); - let+ e2 = self(n - 1); - Filter(fa, e1, e2); - }, - { - let* e1 = self((n - 1) / 2); - let+ e2 = self((n - 1) / 2); - Seq(e1, e2); - }, - { - let* e1 = self((n - 1) / 2); - let+ e2 = self((n - 1) / 2); - Cons(e1, e2); - }, - { - let* e1 = self((n - 1) / 2); - let+ e2 = self((n - 1) / 2); - ListConcat(e1, e2); - }, - { - let* tp = gen_tpat; - let+ e = self(n - 1); - TypFun(tp, e); - }, - { - let* t = gen_typ_sized((n - 1) / 2); - let+ e = self((n - 1) / 2); - TypAp(e, t); - }, - { - let* tp = gen_tpat; - let* t = gen_typ_sized((n - 1) / 2); - let+ e = self((n - 1) / 2); - TyAlias(tp, t, e); - }, - ]) - } - }, - n, - ); - - gen + fix( + (self: int => t(exp), n) => { + switch (n) { + | 0 + | 1 => leaf + | _ => + oneof([ + leaf, + { + let* sizes = sized_arr(n); + let+ exps = + flatten_a(Array.map((size: int) => self(size), sizes)); + ListExp(Array.to_list(exps)); + }, + { + let* sizes = non_single_element_arr(n); + let+ exps = + flatten_a(Array.map((size: int) => self(size), sizes)); + TupleExp(Array.to_list(exps)); + }, + { + let+ inner = self(n - 1); + Test(inner); + }, + { + let+ name = arb_constructor_ident.gen; + Constructor(name, UnknownType(Internal)); + }, + { + let* op = gen_bin_op; + let* e1 = self((n - 1) / 2); + let+ e2 = self((n - 1) / 2); + BinExp(e1, op, e2); + }, + { + // TODO ExpToSegment broken for UnOp + // { + // let* op = gen_op_un; + // let+ e = self((n - 1) / 2); + // UnOp(op, e); + // }, + + let* e1 = self((n - 1) / 3); + let* e2 = self((n - 1) / 3); + let+ e3 = self((n - 1) / 3); + If(e1, e2, e3); + }, + { + let* p = gen_pat_sized((n - 1) / 3); + let* e1 = self((n - 1) / 3); + let+ e2 = self((n - 1) / 3); + Let(p, e1, e2); + }, + { + let* p = gen_pat_sized((n - 1) / 2); + let+ e = self((n - 1) / 2); + Fun(p, e, None); + }, + { + let case = n => { + let p = gen_pat_sized(n / 2); + let e = self(n / 2); + tup2(p, e); + }; + let* e = self(n - 1 / 2); + let* sizes = sized_arr(n - 1 / 2); + let+ cases = flatten_a(Array.map(case, sizes)); + CaseExp(e, Array.to_list(cases)); + }, + { + let* e1 = self((n - 1) / 2); + let+ e2 = + frequency([ + (5, self((n - 1) / 2)), + (1, return(Deferral)), + ]); + ApExp(e1, e2); + }, + { + let* p = gen_pat_sized((n - 1) / 2); + let+ e = self((n - 1) / 2); + FixF(p, e); + }, + { + let* fa = gen_filter_action; + let* e1 = self(n - 1); + let+ e2 = self(n - 1); + Filter(fa, e1, e2); + }, + { + let* e1 = self((n - 1) / 2); + let+ e2 = self((n - 1) / 2); + Seq(e1, e2); + }, + { + let* e1 = self((n - 1) / 2); + let+ e2 = self((n - 1) / 2); + Cons(e1, e2); + }, + { + let* e1 = self((n - 1) / 2); + let+ e2 = self((n - 1) / 2); + ListConcat(e1, e2); + }, + { + let* tp = gen_tpat; + let+ e = self(n - 1); + TypFun(tp, e); + }, + { + let* t = gen_typ_sized((n - 1) / 2); + let+ e = self((n - 1) / 2); + TypAp(e, t); + }, + { + let* tp = gen_tpat; + let* t = gen_typ_sized((n - 1) / 2); + let+ e = self((n - 1) / 2); + TyAlias(tp, t, e); + }, + ]) + } + }, + n, + ) ) and gen_typ_sized: int => QCheck.Gen.t(typ) = n => From ccda1d2eeba32669342a3d3b2c99b1f73aecf5ee Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 11:49:40 -0500 Subject: [PATCH 216/281] Refactor gen_typ_sized to use let notation --- src/haz3lmenhir/AST.re | 56 ++++++++++++++++++++++-------------------- 1 file changed, 29 insertions(+), 27 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 07d006578e..5ea2ead2e6 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -439,33 +439,35 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = | _ => oneof([ leaf_nodes, - join( - map( - (sizes: array(int)) => { - let typs = Array.map((size: int) => self(size), sizes); - - let flattened = flatten_a(typs); - map( - (typs: array(typ)) => TupleType(Array.to_list(typs)), - flattened, - ); - }, - non_single_element_arr(n), - ), - ), - map(t => ArrayType(t), self(n - 1)), - map2( - (t1, t2) => ArrowType(t1, t2), - self((n - 1) / 2), - self((n - 1) / 2), - ), - map(x => TypVar(x), arb_ident.gen), - map2( - (tpat, t) => ForallType(tpat, t), - gen_tpat, - self(n - 1), - ), - map2((tpat, t) => RecType(tpat, t), gen_tpat, self(n - 1)), + { + let* sizes = non_single_element_arr(n); + let+ typs = + flatten_a(Array.map((size: int) => self(size), sizes)); + TupleType(Array.to_list(typs)); + }, + { + let+ t = self(n - 1); + ArrayType(t); + }, + { + let* t1 = self((n - 1) / 2); + let+ t2 = self((n - 1) / 2); + ArrowType(t1, t2); + }, + { + let+ ident = arb_ident.gen; + TypVar(ident); + }, + { + let* gen_tpat = gen_tpat; + let+ t = self(n - 1); + ForallType(gen_tpat, t); + }, + { + let* gen_tpat = gen_tpat; + let+ t = self(n - 1); + RecType(gen_tpat, t); + }, join( map( sizes => { From 109f130ceff9a74ebb81f7ad4e7c6c71fc28f883 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 11:59:43 -0500 Subject: [PATCH 217/281] Refactor sumtype to use let notation --- src/haz3lmenhir/AST.re | 53 +++++++++++++++++++----------------------- 1 file changed, 24 insertions(+), 29 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 5ea2ead2e6..4f2387e4df 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -468,35 +468,30 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = let+ t = self(n - 1); RecType(gen_tpat, t); }, - join( - map( - sizes => { - let sumterms = - Array.map( - (size: int) => { - let optional_typ = option(self(size)); - let constructor = arb_constructor_ident.gen; - let variant = - map2( - (name, typ) => Variant(name, typ), - constructor, - optional_typ, - ); - frequency([ - (5, variant), - (1, return(BadEntry(UnknownType(EmptyHole)))), - ]); - }, - sizes, - ); - - let flattened: t(array(sumterm)) = flatten_a(sumterms); - - map(x => SumTyp(Array.to_list(x)), flattened); - }, - non_empty_arr(n - 1), - ), - ), + { + let* sizes = non_empty_arr(n - 1); + let+ sumterms = + flatten_a( + Array.map( + (size: int) => { + frequency([ + (1, return(BadEntry(UnknownType(EmptyHole)))), + ( + 5, + { + let* optional_typ = option(self(size)); + let+ constructor = arb_constructor_ident.gen; + Variant(constructor, optional_typ); + }, + ), + ]) + }, + sizes, + ), + ); + + SumTyp(Array.to_list(sumterms)); + }, ]) }, n, From 64d1a04d7b5416af5d36e8afd574ec587065c4da Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 12:04:41 -0500 Subject: [PATCH 218/281] Refactor gen_pat_sized to use let notation --- src/haz3lmenhir/AST.re | 72 ++++++++++++++++++------------------------ 1 file changed, 31 insertions(+), 41 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 4f2387e4df..22a2ebcf66 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -524,47 +524,37 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = | _ => oneof([ leaf_nodes, - map2( - (p1, p2) => ConsPat(p1, p2), - self((n - 1) / 2), - self((n - 1) / 2), - ), - join( - map( - sizes => { - let pats = Array.map((size: int) => self(size), sizes); - - let flattened = flatten_a(pats); - - map(x => TuplePat(Array.to_list(x)), flattened); - }, - non_single_element_arr(n - 1), - ), - ), - join( - map( - sizes => { - let pats = Array.map((size: int) => self(size), sizes); - - let flattened = flatten_a(pats); - - map(x => ListPat(Array.to_list(x)), flattened); - }, - sized_arr(n - 1), - ), - ), - map2( - (i, p) => - ApPat(ConstructorPat(i, UnknownType(Internal)), p), // The parser only handles ApPat with a constructor - arb_constructor_ident.gen, - self(n - 1), - ), - map3( - (p, t1, t2) => CastPat(p, t1, t2), - self((n - 1) / 3), - gen_typ_sized((n - 1) / 3), - gen_typ_sized((n - 1) / 3), - ), + { + let* p1 = self((n - 1) / 2); + let+ p2 = self((n - 1) / 2); + ConsPat(p1, p2); + }, + { + let* sizes = non_single_element_arr(n - 1); + let+ pats = + flatten_a(Array.map((size: int) => self(size), sizes)); + TuplePat(Array.to_list(pats)); + }, + { + let* sizes = sized_arr(n - 1); + let+ pats = + flatten_a(Array.map((size: int) => self(size), sizes)); + ListPat(Array.to_list(pats)); + }, + { + let* constructor = arb_constructor_ident.gen; + let+ p = self(n - 1); + ApPat( + ConstructorPat(constructor, UnknownType(Internal)), + p, + ); + }, // The parser only handles ApPat with a constructor + { + let* p = self((n - 1) / 3); + let* t1 = gen_typ_sized((n - 1) / 3); + let+ t2 = gen_typ_sized((n - 1) / 3); + CastPat(p, t1, t2); + }, ]) }; }, From ea5139506f389608de032e1c83d466e81499e529 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 12:06:23 -0500 Subject: [PATCH 219/281] Remove unused gen_exp and gen_typ definitions --- src/haz3lmenhir/AST.re | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 22a2ebcf66..ee8217cdd1 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -562,8 +562,3 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = ) ); // TODO Printers, shrinkers stuff - -let gen_exp = QCheck.Gen.sized(gen_exp_sized); -let gen_typ = QCheck.Gen.sized(gen_typ_sized); - -let arb_exp = QCheck.make(~print=show_exp, gen_exp); From 98e77306c9b535cd62dcbfd263e7d272d68d7e41 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 12:08:31 -0500 Subject: [PATCH 220/281] Rename arb_str to arb_alpha_str --- src/haz3lmenhir/AST.re | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index ee8217cdd1..5e27500786 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -1,6 +1,6 @@ open Sexplib.Std; -let arb_str = QCheck.(string_small_of(Gen.char_range('a', 'z'))); +let arb_alpha_str = QCheck.(string_small_of(Gen.char_range('a', 'z'))); [@deriving (show({with_path: false}), sexp, qcheck, eq)] type filter_action = @@ -173,7 +173,7 @@ type exp = | TyAlias(tpat, typ, exp); let arb_int = QCheck.(map(x => Int(x), small_int)); -let arb_str_exp = QCheck.map(x => String(x), arb_str); // Make strings anything other than `"`" +let arb_str_exp = QCheck.map(x => String(x), arb_alpha_str); // Make strings anything other than `"`" // Floats are positive because we use UnOp minus let arb_float = QCheck.(map(x => Float(x), pos_float)); @@ -509,7 +509,7 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = map(x => IntPat(x), small_int), map(x => FloatPat(x), QCheck.pos_float.gen), map(x => VarPat(x), arb_ident.gen), - map(x => StringPat(x), arb_str.gen), + map(x => StringPat(x), arb_alpha_str.gen), map(x => BoolPat(x), bool), map( x => ConstructorPat(x, UnknownType(Internal)), From ce23f3f76d309479046b72ab9b40f4b1e6000aec Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 12:17:00 -0500 Subject: [PATCH 221/281] Inlining cleanup --- src/haz3lmenhir/AST.re | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 5e27500786..1417c19d5c 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -172,11 +172,6 @@ type exp = | DynamicErrorHole(exp, string) | TyAlias(tpat, typ, exp); -let arb_int = QCheck.(map(x => Int(x), small_int)); -let arb_str_exp = QCheck.map(x => String(x), arb_alpha_str); // Make strings anything other than `"`" - -// Floats are positive because we use UnOp minus -let arb_float = QCheck.(map(x => Float(x), pos_float)); let arb_lower_alpha = QCheck.Gen.char_range('a', 'z'); let arb_constructor_ident = @@ -271,8 +266,6 @@ let non_empty_arr = (n: int) => ) ); -let arb_var = QCheck.(map(x => Var(x), arb_ident)); - let gen_tpat = QCheck.Gen.( let gen_var = map(x => VarTPat(x), arb_ident.gen); @@ -285,10 +278,10 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => QCheck.Gen.( let leaf = oneof([ - arb_int.gen, - arb_str_exp.gen, - arb_float.gen, - arb_var.gen, + map(x => Int(x), small_int), + map(x => String(x), arb_alpha_str.gen), // TODO This should be anything printable other than `"` + map(x => Float(x), QCheck.pos_float.gen), // Floats are positive because we use UnOp minus + map(x => Var(x), arb_ident.gen), map(x => Bool(x), bool), pure(EmptyHole), pure(TupleExp([])), From acc2fca93999dec92e8d6eccfd81b9f341464405 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 12:21:29 -0500 Subject: [PATCH 222/281] Refactor to gen_literal_string --- src/haz3lmenhir/AST.re | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 1417c19d5c..535153f522 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -1,7 +1,5 @@ open Sexplib.Std; -let arb_alpha_str = QCheck.(string_small_of(Gen.char_range('a', 'z'))); - [@deriving (show({with_path: false}), sexp, qcheck, eq)] type filter_action = | Pause @@ -172,14 +170,16 @@ type exp = | DynamicErrorHole(exp, string) | TyAlias(tpat, typ, exp); -let arb_lower_alpha = QCheck.Gen.char_range('a', 'z'); - let arb_constructor_ident = QCheck. // TODO handle full constructor ident including nums ( let leading = Gen.char_range('A', 'Z'); - let tail = string_gen_of_size(Gen.int_range(1, 4), arb_lower_alpha); + let tail = + string_gen_of_size( + Gen.int_range(1, 4), + QCheck.Gen.char_range('a', 'z'), + ); QCheck.map( ident => // if ident is a keyword add a suffix @@ -219,7 +219,10 @@ let arb_ident = | "in" => "keyword" | _ => ident }, - string_gen_of_size(Gen.int_range(1, 1), arb_lower_alpha), + string_gen_of_size( + Gen.int_range(1, 1), + QCheck.Gen.char_range('a', 'z'), + ), ) ); @@ -274,12 +277,15 @@ let gen_tpat = oneof([gen_var, gen_empty]) ); +// TODO This should be anything printable other than `"` +let gen_literal_string = QCheck.Gen.(string_small_of(char_range('a', 'z'))); + let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => QCheck.Gen.( let leaf = oneof([ map(x => Int(x), small_int), - map(x => String(x), arb_alpha_str.gen), // TODO This should be anything printable other than `"` + map(x => String(x), gen_literal_string), map(x => Float(x), QCheck.pos_float.gen), // Floats are positive because we use UnOp minus map(x => Var(x), arb_ident.gen), map(x => Bool(x), bool), @@ -502,7 +508,7 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = map(x => IntPat(x), small_int), map(x => FloatPat(x), QCheck.pos_float.gen), map(x => VarPat(x), arb_ident.gen), - map(x => StringPat(x), arb_alpha_str.gen), + map(x => StringPat(x), gen_literal_string), map(x => BoolPat(x), bool), map( x => ConstructorPat(x, UnknownType(Internal)), From 926ab680172ac0e37bbbacc2c42ef53d0b06fd87 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 12:25:40 -0500 Subject: [PATCH 223/281] More let notation --- src/haz3lmenhir/AST.re | 53 ++++++++++++++++-------------------------- 1 file changed, 20 insertions(+), 33 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 535153f522..3ef93ca287 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -226,50 +226,37 @@ let arb_ident = ) ); -let sized_arr = (n: int) => +let sized_arr = (n: int): QCheck.Gen.t(array(int)) => QCheck.Gen.( - let list_size = n <= 1 ? pure(0) : int_range(2, n); - - list_size - >>= ( - x => - switch (x) { - | 0 => pure([||]) - | _ => nat_split(~size=x, n - x) - } - ) + let* list_size = n <= 1 ? pure(0) : int_range(2, n); + switch (list_size) { + | 0 => pure([||]) + | _ => nat_split(~size=list_size, n - list_size) + } ); -let non_single_element_arr = (n: int) => +let non_single_element_arr = (n: int): QCheck.Gen.t(array(int)) => QCheck.Gen.( - let list_size = + let* list_size = frequency([(1, pure(0)), (n, n <= 1 ? pure(0) : int_range(2, n))]); - list_size - >>= ( - x => - switch (x) { - | 0 => pure([||]) - | _ => nat_split(~size=x, n - x) - } - ) + switch (list_size) { + | 0 => pure([||]) + | _ => nat_split(~size=list_size, n - list_size) + } ); -let non_empty_arr = (n: int) => +let non_empty_arr = (n: int): QCheck.Gen.t(array(int)) => QCheck.Gen.( - let list_size = n <= 1 ? pure(0) : int_range(1, n); + let* list_size = n <= 1 ? pure(0) : int_range(1, n); - list_size - >>= ( - x => - switch (x) { - | 0 => pure([|0|]) // I'm a bit concerned about this not tracking size. But it seems to work in practice. - | _ => nat_split(~size=x, n - x) - } - ) + switch (list_size) { + | 0 => pure([|0|]) // I'm a bit concerned about this not tracking size. But it seems to work in practice. + | _ => nat_split(~size=list_size, n - list_size) + } ); -let gen_tpat = +let gen_tpat: QCheck.Gen.t(tpat) = QCheck.Gen.( let gen_var = map(x => VarTPat(x), arb_ident.gen); let gen_empty = pure(EmptyHoleTPat); @@ -278,7 +265,7 @@ let gen_tpat = ); // TODO This should be anything printable other than `"` -let gen_literal_string = QCheck.Gen.(string_small_of(char_range('a', 'z'))); +let gen_literal_string: QCheck.Gen.t(string) = QCheck.Gen.(string_small_of(char_range('a', 'z'))); let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => QCheck.Gen.( From 7472c64499fa15f48c29b818ad594c6bbb7491b1 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 12:27:32 -0500 Subject: [PATCH 224/281] Add annotation --- src/haz3lmenhir/AST.re | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 3ef93ca287..eaf77c77af 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -265,7 +265,8 @@ let gen_tpat: QCheck.Gen.t(tpat) = ); // TODO This should be anything printable other than `"` -let gen_literal_string: QCheck.Gen.t(string) = QCheck.Gen.(string_small_of(char_range('a', 'z'))); +let gen_literal_string: QCheck.Gen.t(string) = + QCheck.Gen.(string_small_of(char_range('a', 'z'))); let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => QCheck.Gen.( From 24ebb178300c6e377072066bacda756b1fbd3151 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 12:31:24 -0500 Subject: [PATCH 225/281] Cleanup --- src/haz3lmenhir/AST.re | 25 +++++-------------------- 1 file changed, 5 insertions(+), 20 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index eaf77c77af..9e8ac80c8b 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -182,7 +182,7 @@ let arb_constructor_ident = ); QCheck.map( ident => - // if ident is a keyword add a suffix + // if ident is a keyword remap switch (ident) { | "Int" | "Float" @@ -205,24 +205,9 @@ let arb_constructor_ident = let arb_ident = QCheck.( // TODO make this support full indent instead of just lower alpha - QCheck.map( - ident => - // if ident is a keyword add a suffix - switch (ident) { - | "let" - | "if" - | "pause" - | "debug" - | "hide" - | "eval" - | "rec" - | "in" => "keyword" - | _ => ident - }, - string_gen_of_size( - Gen.int_range(1, 1), - QCheck.Gen.char_range('a', 'z'), - ), + string_gen_of_size( + Gen.int_range(1, 1), + QCheck.Gen.char_range('a', 'z'), ) ); @@ -260,7 +245,7 @@ let gen_tpat: QCheck.Gen.t(tpat) = QCheck.Gen.( let gen_var = map(x => VarTPat(x), arb_ident.gen); let gen_empty = pure(EmptyHoleTPat); - // let gen_invalid = map(x => InvalidTPat(x), arb_ident.gen); + // let gen_invalid = map(x => InvalidTPat(x), arb_ident.gen); // Menhir parser doesn't actually support invalid tpat oneof([gen_var, gen_empty]) ); From 6618e8669a405afb026479e2446754c5969a2271 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 12:37:47 -0500 Subject: [PATCH 226/281] Turn arb_constructor_ident into gen_constructor_ident --- src/haz3lmenhir/AST.re | 58 ++++++++++++++++++------------------------ 1 file changed, 25 insertions(+), 33 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 9e8ac80c8b..cff01b0175 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -170,34 +170,26 @@ type exp = | DynamicErrorHole(exp, string) | TyAlias(tpat, typ, exp); -let arb_constructor_ident = - QCheck. - // TODO handle full constructor ident including nums - ( - let leading = Gen.char_range('A', 'Z'); - let tail = - string_gen_of_size( - Gen.int_range(1, 4), - QCheck.Gen.char_range('a', 'z'), - ); - QCheck.map( - ident => - // if ident is a keyword remap - switch (ident) { - | "Int" - | "Float" - | "String" - | "Unknown" - | "Internal" - | "Bool" => "keyword" - | _ => ident - }, - make( - ~print=t => t, - Gen.map2((l, t) => String.make(1, l) ++ t, leading, tail.gen), - ), - ) - ); +let gen_constructor_ident = + // TODO handle full constructor ident including nums + QCheck.Gen.( + let leading = char_range('A', 'Z'); + let tail = string_size(~gen=char_range('a', 'z'), int_range(1, 4)); + map( + ident => + // if ident is a keyword remap + switch (ident) { + | "Int" + | "Float" + | "String" + | "Unknown" + | "Internal" + | "Bool" => "keyword" + | _ => ident + }, + map2((l, t) => String.make(1, l) ++ t, leading, tail), + ) + ); // ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* // Currently an issue if the keyword is a prefix of another word. `let ? = ina in ?` @@ -291,7 +283,7 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => Test(inner); }, { - let+ name = arb_constructor_ident.gen; + let+ name = gen_constructor_ident; Constructor(name, UnknownType(Internal)); }, { @@ -402,7 +394,7 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = return(BoolType), return(UnitType), map(x => UnknownType(x), arb_typ_provenance.gen), - map(x => SumTyp([Variant(x, None)]), arb_constructor_ident.gen), + map(x => SumTyp([Variant(x, None)]), gen_constructor_ident), ]); fix( (self, n) => @@ -452,7 +444,7 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = 5, { let* optional_typ = option(self(size)); - let+ constructor = arb_constructor_ident.gen; + let+ constructor = gen_constructor_ident; Variant(constructor, optional_typ); }, ), @@ -485,7 +477,7 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = map(x => BoolPat(x), bool), map( x => ConstructorPat(x, UnknownType(Internal)), - arb_constructor_ident.gen, + gen_constructor_ident, ), return(TuplePat([])), return(ListPat([])), @@ -514,7 +506,7 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = ListPat(Array.to_list(pats)); }, { - let* constructor = arb_constructor_ident.gen; + let* constructor = gen_constructor_ident; let+ p = self(n - 1); ApPat( ConstructorPat(constructor, UnknownType(Internal)), From 35ddd723a79287a2b717873b299bd46198410b9c Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 12:42:02 -0500 Subject: [PATCH 227/281] Rename generators --- src/haz3lmenhir/AST.re | 77 ++++++++++++++++++++---------------------- 1 file changed, 37 insertions(+), 40 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index cff01b0175..a95fa54dee 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -170,40 +170,37 @@ type exp = | DynamicErrorHole(exp, string) | TyAlias(tpat, typ, exp); -let gen_constructor_ident = +let gen_constructor_ident: QCheck.Gen.t(string) = // TODO handle full constructor ident including nums QCheck.Gen.( - let leading = char_range('A', 'Z'); - let tail = string_size(~gen=char_range('a', 'z'), int_range(1, 4)); - map( - ident => - // if ident is a keyword remap - switch (ident) { - | "Int" - | "Float" - | "String" - | "Unknown" - | "Internal" - | "Bool" => "keyword" - | _ => ident - }, - map2((l, t) => String.make(1, l) ++ t, leading, tail), - ) + let* leading = char_range('A', 'Z'); + let+ tail = string_size(~gen=char_range('a', 'z'), int_range(1, 4)); + let ident = String.make(1, leading) ++ tail; + // if ident is a keyword remap + switch (ident) { + | "Int" + | "Float" + | "String" + | "Unknown" + | "Internal" + | "Bool" => "keyword" + | _ => ident + } ); // ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* // Currently an issue if the keyword is a prefix of another word. `let ? = ina in ?` // Temporarily doing single char identifiers as a fix -let arb_ident = - QCheck.( +let gen_ident = + QCheck.Gen.( // TODO make this support full indent instead of just lower alpha - string_gen_of_size( - Gen.int_range(1, 1), - QCheck.Gen.char_range('a', 'z'), + string_size( + ~gen=char_range('a', 'z'), + int_range(1, 1), ) ); -let sized_arr = (n: int): QCheck.Gen.t(array(int)) => +let gen_sized_array = (n: int): QCheck.Gen.t(array(int)) => QCheck.Gen.( let* list_size = n <= 1 ? pure(0) : int_range(2, n); switch (list_size) { @@ -212,7 +209,7 @@ let sized_arr = (n: int): QCheck.Gen.t(array(int)) => } ); -let non_single_element_arr = (n: int): QCheck.Gen.t(array(int)) => +let gen_non_singleton_array = (n: int): QCheck.Gen.t(array(int)) => QCheck.Gen.( let* list_size = frequency([(1, pure(0)), (n, n <= 1 ? pure(0) : int_range(2, n))]); @@ -223,7 +220,7 @@ let non_single_element_arr = (n: int): QCheck.Gen.t(array(int)) => } ); -let non_empty_arr = (n: int): QCheck.Gen.t(array(int)) => +let gen_non_empty_array = (n: int): QCheck.Gen.t(array(int)) => QCheck.Gen.( let* list_size = n <= 1 ? pure(0) : int_range(1, n); @@ -235,14 +232,14 @@ let non_empty_arr = (n: int): QCheck.Gen.t(array(int)) => let gen_tpat: QCheck.Gen.t(tpat) = QCheck.Gen.( - let gen_var = map(x => VarTPat(x), arb_ident.gen); + let gen_var = map(x => VarTPat(x), gen_ident); let gen_empty = pure(EmptyHoleTPat); - // let gen_invalid = map(x => InvalidTPat(x), arb_ident.gen); // Menhir parser doesn't actually support invalid tpat + // let gen_invalid = map(x => InvalidTPat(x), gen_ident); // Menhir parser doesn't actually support invalid tpat oneof([gen_var, gen_empty]) ); // TODO This should be anything printable other than `"` -let gen_literal_string: QCheck.Gen.t(string) = +let gen_string_literal: QCheck.Gen.t(string) = QCheck.Gen.(string_small_of(char_range('a', 'z'))); let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => @@ -250,9 +247,9 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => let leaf = oneof([ map(x => Int(x), small_int), - map(x => String(x), gen_literal_string), + map(x => String(x), gen_string_literal), map(x => Float(x), QCheck.pos_float.gen), // Floats are positive because we use UnOp minus - map(x => Var(x), arb_ident.gen), + map(x => Var(x), gen_ident), map(x => Bool(x), bool), pure(EmptyHole), pure(TupleExp([])), @@ -267,13 +264,13 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => oneof([ leaf, { - let* sizes = sized_arr(n); + let* sizes = gen_sized_array(n); let+ exps = flatten_a(Array.map((size: int) => self(size), sizes)); ListExp(Array.to_list(exps)); }, { - let* sizes = non_single_element_arr(n); + let* sizes = gen_non_singleton_array(n); let+ exps = flatten_a(Array.map((size: int) => self(size), sizes)); TupleExp(Array.to_list(exps)); @@ -323,7 +320,7 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => tup2(p, e); }; let* e = self(n - 1 / 2); - let* sizes = sized_arr(n - 1 / 2); + let* sizes = gen_sized_array(n - 1 / 2); let+ cases = flatten_a(Array.map(case, sizes)); CaseExp(e, Array.to_list(cases)); }, @@ -404,7 +401,7 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = oneof([ leaf_nodes, { - let* sizes = non_single_element_arr(n); + let* sizes = gen_non_singleton_array(n); let+ typs = flatten_a(Array.map((size: int) => self(size), sizes)); TupleType(Array.to_list(typs)); @@ -419,7 +416,7 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = ArrowType(t1, t2); }, { - let+ ident = arb_ident.gen; + let+ ident = gen_ident; TypVar(ident); }, { @@ -433,7 +430,7 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = RecType(gen_tpat, t); }, { - let* sizes = non_empty_arr(n - 1); + let* sizes = gen_non_empty_array(n - 1); let+ sumterms = flatten_a( Array.map( @@ -472,8 +469,8 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = return(EmptyHolePat), map(x => IntPat(x), small_int), map(x => FloatPat(x), QCheck.pos_float.gen), - map(x => VarPat(x), arb_ident.gen), - map(x => StringPat(x), gen_literal_string), + map(x => VarPat(x), gen_ident), + map(x => StringPat(x), gen_string_literal), map(x => BoolPat(x), bool), map( x => ConstructorPat(x, UnknownType(Internal)), @@ -494,13 +491,13 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = ConsPat(p1, p2); }, { - let* sizes = non_single_element_arr(n - 1); + let* sizes = gen_non_singleton_array(n - 1); let+ pats = flatten_a(Array.map((size: int) => self(size), sizes)); TuplePat(Array.to_list(pats)); }, { - let* sizes = sized_arr(n - 1); + let* sizes = gen_sized_array(n - 1); let+ pats = flatten_a(Array.map((size: int) => self(size), sizes)); ListPat(Array.to_list(pats)); From 9620c1738cec882d5074c7fc288fb79b8da26666 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 13:04:48 -0500 Subject: [PATCH 228/281] Add detailed documentation for generator functions in AST --- src/haz3lmenhir/AST.re | 88 +++++++++++++++++++++++++++++++++++++++--- 1 file changed, 83 insertions(+), 5 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index a95fa54dee..c0156b0f0d 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -170,6 +170,13 @@ type exp = | DynamicErrorHole(exp, string) | TyAlias(tpat, typ, exp); +/** + * Generates a random CONSTRUCTOR_IDENT string. Used for CONSTRUCTOR_IDENT in the lexer. + * + * @return A QCheck generator for Constructor Identifier. + * + * ['A'-'Z'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* + */ let gen_constructor_ident: QCheck.Gen.t(string) = // TODO handle full constructor ident including nums QCheck.Gen.( @@ -188,10 +195,17 @@ let gen_constructor_ident: QCheck.Gen.t(string) = } ); -// ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* -// Currently an issue if the keyword is a prefix of another word. `let ? = ina in ?` -// Temporarily doing single char identifiers as a fix -let gen_ident = +/** + * Generates a random IDENT string. Used for IDENT in the lexer. + * + * @return A QCheck generator for Identifier. + * + * ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* + */ +let gen_ident: QCheck.Gen.t(string) = + // TODO Currently there is an issue if the keyword is a prefix of another word. + // `let ? = ina in ?` + // Temporarily doing single char identifiers as a fix QCheck.Gen.( // TODO make this support full indent instead of just lower alpha string_size( @@ -200,6 +214,15 @@ let gen_ident = ) ); +/** + * Generates an array of natural numbers of a given size. + * Useful for generating recursive structures with arrays/lists. + * + * @param size - The size of the array, which also represents the number of elements in the array. + * @return A QCheck generator that produces arrays of integers that have a size (sum of elements + num of elements) of n + + * This function is useful for size tracking purposes. + */ let gen_sized_array = (n: int): QCheck.Gen.t(array(int)) => QCheck.Gen.( let* list_size = n <= 1 ? pure(0) : int_range(2, n); @@ -209,6 +232,15 @@ let gen_sized_array = (n: int): QCheck.Gen.t(array(int)) => } ); +/** + * Generates an array of natural numbers that is either empty or has a length of at least 2. + * Useful for generating recursive structures with arrays/lists. + * + * @param n The size parameter used for generating the array. + * @return A QCheck generator that produces arrays of integers that have a size (sum of elements + num of elements) of n + * + * This function is useful for size tracking purposes, similar to `gen_sized_array`. + */ let gen_non_singleton_array = (n: int): QCheck.Gen.t(array(int)) => QCheck.Gen.( let* list_size = @@ -220,6 +252,15 @@ let gen_non_singleton_array = (n: int): QCheck.Gen.t(array(int)) => } ); +/** + * Generates an array of natural numbers has a length of at least 1. + * Useful for generating recursive structures with arrays/lists. + * + * @param n The size parameter used for generating the array. + * @return A QCheck generator that produces arrays of integers that have a size (sum of elements + num of elements) of n + * + * This function is useful for size tracking purposes, similar to `gen_sized_array`. + */ let gen_non_empty_array = (n: int): QCheck.Gen.t(array(int)) => QCheck.Gen.( let* list_size = n <= 1 ? pure(0) : int_range(1, n); @@ -230,6 +271,11 @@ let gen_non_empty_array = (n: int): QCheck.Gen.t(array(int)) => } ); +/** + * Generates a random `tpat` value using QCheck. + * + * @return A generator for `tpat` values. + */ let gen_tpat: QCheck.Gen.t(tpat) = QCheck.Gen.( let gen_var = map(x => VarTPat(x), gen_ident); @@ -238,10 +284,23 @@ let gen_tpat: QCheck.Gen.t(tpat) = oneof([gen_var, gen_empty]) ); -// TODO This should be anything printable other than `"` +/** + * Generates a string literal for use in the program. + * This generator produces strings that match the `string` pattern in the lexer. + */ let gen_string_literal: QCheck.Gen.t(string) = + // TODO This should be anything printable other than `"` QCheck.Gen.(string_small_of(char_range('a', 'z'))); +/** + * Generates an expression of a given size. + * + * @param n The size of the expression to generate. + * @return A generator for expressions of the specified size. + * + * This function is currently used for property tests between MakeTerm and the Menhir parser, + * so it's not currently set up to generate every possible expression. + */ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => QCheck.Gen.( let leaf = @@ -381,6 +440,15 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => n, ) ) +/** + * Generates a type of a given size. + * + * @param n The size of the type to generate. + * @return A generator for types of the specified size. + * + * This function is currently used for property tests between MakeTerm and the Menhir parser, + * so it's not currently set up to generate every possible type. + */ and gen_typ_sized: int => QCheck.Gen.t(typ) = n => QCheck.Gen.( @@ -458,6 +526,16 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = n, ) ) + +/** + * Generates an pattern of a given size. + * + * @param n The size of the pattern to generate. + * @return A generator for expressions of the specified size. + * + * This function is currently used for property tests between MakeTerm and the Menhir parser, + * so it's not currently set up to generate every possible pattern. + */ and gen_pat_sized: int => QCheck.Gen.t(pat) = n => QCheck.Gen.( From ae1ae3d8186f3de86713386edc5e5f3faa1c80af Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 13:07:04 -0500 Subject: [PATCH 229/281] Remove TODO comment regarding builtins in the parser --- test/Test_Menhir.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 94ebac1864..cd92739191 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -20,7 +20,7 @@ let strip_parens_and_add_builtins = VarMap.lookup(Haz3lcore.Builtins.Pervasives.builtins, x); cont( switch (builtin) { - | Some(Fn(_, _, _)) => cont(BuiltinFun(x) |> Exp.fresh) // TODO Decide whether these should be builtins in the parser or vars + | Some(Fn(_, _, _)) => cont(BuiltinFun(x) |> Exp.fresh) | Some(Const(_, _)) | None => cont(e) }, From ce578a32f6e4c1ab4b70707351b88447dacaa88f Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Sun, 22 Dec 2024 13:15:18 -0500 Subject: [PATCH 230/281] Remove invalid deferral test --- test/Test_Elaboration.re | 22 ---------------------- 1 file changed, 22 deletions(-) diff --git a/test/Test_Elaboration.re b/test/Test_Elaboration.re index e12114ad66..b9fcd3572b 100644 --- a/test/Test_Elaboration.re +++ b/test/Test_Elaboration.re @@ -627,26 +627,6 @@ let f = let filter_menhir = () => alco_check_menhir("Filter test (menhir)", filter_str, filter_uexp); - //NOTE: left out until deferral elaborations are fixed - // let deferred_str = " - // (fun x -> 4 + 5)(_) - // "; - // let deferred_uexp: Exp.t = - // DeferredAp( - // Fun( - // Var("x") |> Pat.fresh, - // BinOp(Int(Plus), Int(4) |> Exp.fresh, Int(5) |> Exp.fresh) - // |> Exp.fresh, - // None, - // None, - // ) - // |> Exp.fresh, - // [Deferral(InAp) |> Exp.fresh], - // ) - // |> Exp.fresh; - // let deferred_ap_menhir = () => - // alco_check_menhir("Deferred Ap Test (menhir)", deferred_str, deferred_uexp); - let undefined_str = " undef "; @@ -768,8 +748,6 @@ x test_case("Inconsistent case (menhir)", `Quick, inconsistent_case_menhir), test_case("ap fun (menhir)", `Quick, ap_fun_menhir), test_case("Consistent if (menhir)", `Quick, consistent_if_menhir), - //NOTE: left out until deferral elaborations are fixed - // test_case("Deffered Ap Test (menhir)", `Quick, deferred_ap_menhir), test_case("Undefined test (menhir)", `Quick, undefined_menhir), test_case("List exp (menhir)", `Quick, list_exp_menhir), test_case("Invalid test (menhir)", `Quick, invalid_menhir), From a5b5421bbe8564957d33bdea2b722d60f3b557d7 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 24 Dec 2024 12:30:41 -0500 Subject: [PATCH 231/281] Upgrade junit_alcotest to 2.1.0 and uncomment skipped tests --- dune-project | 25 ++++++++++++++++++------- hazel.opam | 2 +- hazel.opam.locked | 4 ++-- test/Test_Menhir.re | 42 ++++++++++++++++++++---------------------- 4 files changed, 41 insertions(+), 32 deletions(-) diff --git a/dune-project b/dune-project index a8e9d11527..96cc1c1de3 100644 --- a/dune-project +++ b/dune-project @@ -1,4 +1,5 @@ (lang dune 3.16) + (using menhir 2.0) (name hazel) @@ -9,6 +10,7 @@ (github hazelgrove/hazel)) (authors "Hazel Development Team") + (maintainers "Hazel Development Team") (license MIT) @@ -16,8 +18,9 @@ (package (name hazel) (allow_empty) - (synopsis "Hazel, a live functional programming environment with typed holes") -; (description "A longer description") + (synopsis + "Hazel, a live functional programming environment with typed holes") + ; (description "A longer description") ; (tags ; (topics "to describe" your project)) (depends @@ -26,23 +29,31 @@ (menhir (>= 2.0)) yojson - (reason (>= 3.12.0)) + (reason + (>= 3.12.0)) ppx_yojson_conv_lib ppx_yojson_conv incr_dom bisect_ppx - (omd (>= 2.0.0~alpha4)) + (omd + (>= 2.0.0~alpha4)) ezjs_idb bonsai ppx_deriving ptmap - (uuidm (= 0.9.8)) ; 0.9.9 has breaking deprecated changes + (uuidm + (= 0.9.8)) ; 0.9.9 has breaking deprecated changes unionFind ocamlformat - (junit_alcotest :with-test) + (junit_alcotest + (and + (>= 2.1.0) + :with-test)) ocaml-lsp-server qcheck qcheck-alcotest - ppx_deriving_qcheck)) ; After upgrading to opam 2.2 use with-dev https://opam.ocaml.org/blog/opam-2-2-0/ + ppx_deriving_qcheck)) + +; After upgrading to opam 2.2 use with-dev https://opam.ocaml.org/blog/opam-2-2-0/ ; See the complete stanza docs at https://dune.readthedocs.io/en/stable/reference/dune-project/index.html diff --git a/hazel.opam b/hazel.opam index 16ed5457ba..00159279fc 100644 --- a/hazel.opam +++ b/hazel.opam @@ -24,7 +24,7 @@ depends: [ "uuidm" {= "0.9.8"} "unionFind" "ocamlformat" - "junit_alcotest" {with-test} + "junit_alcotest" {>= "2.1.0" & with-test} "ocaml-lsp-server" "qcheck" "qcheck-alcotest" diff --git a/hazel.opam.locked b/hazel.opam.locked index 399042a839..dd4d38bbb8 100644 --- a/hazel.opam.locked +++ b/hazel.opam.locked @@ -102,8 +102,8 @@ depends: [ "jsonm" {= "1.0.2"} "jsonrpc" {= "1.19.0"} "jst-config" {= "v0.16.0"} - "junit" {= "2.0.2" & with-test} - "junit_alcotest" {= "2.0.2" & with-test} + "junit" {= "2.1.0" & with-test} + "junit_alcotest" {= "2.1.0" & with-test} "lambdasoup" {= "1.1.1"} "logs" {= "0.7.0"} "lsp" {= "1.19.0"} diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index cd92739191..311432f8ed 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -832,28 +832,26 @@ let ex5 = list_of_mylist(x) in |}, ), // This fails because MakeTerm can't handle left to right keyword prefixes. - // Skipped tests are commented out because of junit alcotest bug https://github.com/Khady/ocaml-junit/issues/9 - // skip_menhir_maketerm_equivalent_test( - // "Prefixed keyword parses", - // {|let ? = ina in ?|}, - // ), - // // Menhir is doing the skipped better than MakeTerm - // skip_menhir_maketerm_equivalent_test( - // "Prefixed keyword parses", - // {|type ? = rec ? -> + Aramj -> Bool in ?|}, - // ), - // skip_menhir_maketerm_equivalent_test( - // "List concat and typap", - // {|type ? = (+ Ulog, () -> Float) in let (()) = (()) in 0.001536|}, - // ), - // skip_menhir_maketerm_equivalent_test( - // "Sum in product in typeap", - // {|((fun _ -> b)) @< [(+ Kfgii, Float)] >|}, - // ), - // skip_menhir_maketerm_equivalent_test( - // "Non-unique constructors currently throws in equality", - // {|type ? = ((+ ? + ?)) in []|}, - // ), + skip_menhir_maketerm_equivalent_test( + "Prefixed keyword parses", + {|let ? = ina in ?|}, + ), + skip_menhir_maketerm_equivalent_test( + "Sum type messed up in make term", + {|type ? = rec ? -> + Aramj -> Bool in ?|}, + ), + skip_menhir_maketerm_equivalent_test( + "List concat and typap", + {|type ? = (+ Ulog, () -> Float) in let (()) = (()) in 0.001536|}, + ), + skip_menhir_maketerm_equivalent_test( + "Sum in product in typeap", + {|((fun _ -> b)) @< [(+ Kfgii, Float)] >|}, + ), + skip_menhir_maketerm_equivalent_test( + "Non-unique constructors currently throws in equality", + {|type ? = ((+ ? + ?)) in []|}, + ), QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), // Disabled due to bugs in ExpToSegment // e.g. https://github.com/hazelgrove/hazel/issues/1445 From 6a84653bbab41e774bac290bb4d3957cfa8b9a94 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 14:34:14 -0500 Subject: [PATCH 232/281] Refactor identifier generation to handle keywords and clean up comments --- src/haz3lmenhir/AST.re | 23 ++++++----------------- 1 file changed, 6 insertions(+), 17 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index c0156b0f0d..3ee02d2aa8 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -183,15 +183,10 @@ let gen_constructor_ident: QCheck.Gen.t(string) = let* leading = char_range('A', 'Z'); let+ tail = string_size(~gen=char_range('a', 'z'), int_range(1, 4)); let ident = String.make(1, leading) ++ tail; - // if ident is a keyword remap - switch (ident) { - | "Int" - | "Float" - | "String" - | "Unknown" - | "Internal" - | "Bool" => "keyword" - | _ => ident + if (List.exists(a => a == ident, Haz3lcore.Form.base_typs)) { + "Keyword"; + } else { + ident; } ); @@ -203,16 +198,10 @@ let gen_constructor_ident: QCheck.Gen.t(string) = * ['a'-'z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* */ let gen_ident: QCheck.Gen.t(string) = - // TODO Currently there is an issue if the keyword is a prefix of another word. + // Currently there is an issue if the keyword is a prefix of another word. // `let ? = ina in ?` // Temporarily doing single char identifiers as a fix - QCheck.Gen.( - // TODO make this support full indent instead of just lower alpha - string_size( - ~gen=char_range('a', 'z'), - int_range(1, 1), - ) - ); + QCheck.Gen.(string_size(~gen=char_range('a', 'z'), int_range(1, 1))); /** * Generates an array of natural numbers of a given size. From aca41b94e4958092fd9f9ba0fb2d33eb48010980 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 14:37:55 -0500 Subject: [PATCH 233/281] Add "string_split" to builtins and add comment to Builtins --- src/haz3lcore/dynamics/Builtins.re | 2 ++ src/haz3lmenhir/Lexer.mll | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/haz3lcore/dynamics/Builtins.re b/src/haz3lcore/dynamics/Builtins.re index 2f722caa85..218f84c577 100644 --- a/src/haz3lcore/dynamics/Builtins.re +++ b/src/haz3lcore/dynamics/Builtins.re @@ -308,6 +308,8 @@ module Pervasives = { }; open Impls; + + // Update src/haz3lmenhir/Lexer.mll when any new builtin is added let builtins = VarMap.empty |> const("infinity", Float, infinity) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index 289d0c6b30..0f68f2b754 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -37,7 +37,7 @@ let ints = ['0'-'9']+ rule token = parse | "undef" { UNDEF} - | "infinity" | "neg_infinity" | "nan" | "epsilon_float" | "pi" | "max_int" | "min_int" | "is_finite" | "is_infinite" | "int_of_float" | "float_of_int" | "string_of_int" | "string_of_float" | "string_of_bool" | "int_of_string" | "float_of_string" | "bool_of_string" | "abs" | "abs_float" | "ceil" | "floor" | "exp" | "log" | "log10" | "sqrt" | "sin" | "cos" | "tan" | "asin" | "acos" | "atan" | "mod" | "string_length" | "string_compare" | "string_trim" | "string_concat" | "string_sub" { BUILTIN(Lexing.lexeme lexbuf)} + | "infinity" | "neg_infinity" | "nan" | "epsilon_float" | "pi" | "max_int" | "min_int" | "is_finite" | "is_infinite" | "int_of_float" | "float_of_int" | "string_of_int" | "string_of_float" | "string_of_bool" | "int_of_string" | "float_of_string" | "bool_of_string" | "abs" | "abs_float" | "ceil" | "floor" | "exp" | "log" | "log10" | "sqrt" | "sin" | "cos" | "tan" | "asin" | "acos" | "atan" | "mod" | "string_length" | "string_compare" | "string_trim" | "string_concat" | "string_sub" | "string_split" { BUILTIN(Lexing.lexeme lexbuf)} | "-." { MINUS_FLOAT } | whitespace {token lexbuf } | newline { advance_line lexbuf; token lexbuf} From 4d013f8df2fe64d92ee05cb81f28c4076d662e74 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 14:40:08 -0500 Subject: [PATCH 234/281] Move MINUS_FLOAT in Lexer --- src/haz3lmenhir/Lexer.mll | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index 0f68f2b754..89e7ff7a70 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -38,7 +38,6 @@ rule token = parse | "undef" { UNDEF} | "infinity" | "neg_infinity" | "nan" | "epsilon_float" | "pi" | "max_int" | "min_int" | "is_finite" | "is_infinite" | "int_of_float" | "float_of_int" | "string_of_int" | "string_of_float" | "string_of_bool" | "int_of_string" | "float_of_string" | "bool_of_string" | "abs" | "abs_float" | "ceil" | "floor" | "exp" | "log" | "log10" | "sqrt" | "sin" | "cos" | "tan" | "asin" | "acos" | "atan" | "mod" | "string_length" | "string_compare" | "string_trim" | "string_concat" | "string_sub" | "string_split" { BUILTIN(Lexing.lexeme lexbuf)} - | "-." { MINUS_FLOAT } | whitespace {token lexbuf } | newline { advance_line lexbuf; token lexbuf} | ints as i { INT (int_of_string i) } @@ -78,6 +77,7 @@ rule token = | ">=" { GREATER_THAN_EQUAL } (* Float ops *) | "+." { PLUS_FLOAT } + | "-." { MINUS_FLOAT } | "*." { TIMES_FLOAT } | "/." { DIVIDE_FLOAT } | "**." {POWER_FLOAT} From d7165112d157ea4c0825548f04fb150c8ac2dc86 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 14:40:34 -0500 Subject: [PATCH 235/281] Remove TODO comment --- src/haz3lmenhir/Lexer.mll | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lmenhir/Lexer.mll b/src/haz3lmenhir/Lexer.mll index 89e7ff7a70..6b87f803e9 100644 --- a/src/haz3lmenhir/Lexer.mll +++ b/src/haz3lmenhir/Lexer.mll @@ -124,7 +124,7 @@ rule token = | "type" {TYP} | "$" {DOLLAR_SIGN} | "~" {TILDE} - | "?t" {T_TYP} (* TODO These make it very easy to get an unparseable program *) + | "?t" {T_TYP} | "?p" {P_PAT} | "?tp" {TP_TPAT} | "?e" {E_EXP} From 10aa2384c205bdeff032d8accc51b44a9d265f10 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 15:04:05 -0500 Subject: [PATCH 236/281] Fix case statements in exptosegment --- src/haz3lcore/pretty/ExpToSegment.re | 11 ++++++----- test/Test_ExpToSegment.re | 2 +- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index 9e88bcbd73..9fa4b15bde 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -445,11 +445,12 @@ let rec exp_to_pretty = (~settings: Settings.t, exp: Exp.t): pretty => { @ ( List.map2( (id, (p, e)) => - settings.inline - ? [] - : [Secondary(Secondary.mk_newline(Id.mk()))] - @ [mk_form("rule", id, [p])] - @ (e |> fold_if(settings.fold_case_clauses)), + ( + settings.inline + ? [] : [Secondary(Secondary.mk_newline(Id.mk()))] + ) + @ [mk_form("rule", id, [p])] + @ (e |> fold_if(settings.fold_case_clauses)), ids, rs, ) diff --git a/test/Test_ExpToSegment.re b/test/Test_ExpToSegment.re index 505cfc281f..a9844790da 100644 --- a/test/Test_ExpToSegment.re +++ b/test/Test_ExpToSegment.re @@ -67,7 +67,7 @@ let tests = ( string, "Match statement", serialized, - "case x end" // TODO Why is this not serializing the cases + "case x | A => 1| B => 2 end", ); }, ), From d1b3a067a4848fa647d6a6254e9d353e6013fdd1 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 15:44:01 -0500 Subject: [PATCH 237/281] Move parentheses into conversion --- src/haz3lmenhir/Conversion.re | 16 ++++++++++--- test/Test_Menhir.re | 44 ++--------------------------------- 2 files changed, 15 insertions(+), 45 deletions(-) diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index a4311c5554..f204f5edd0 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -208,7 +208,7 @@ module rec Exp: { if (List.length(t) == 1) { Parens(of_menhir_ast(List.hd(t))); } else { - Tuple(List.map(of_menhir_ast, t)); + Parens(Tuple(List.map(of_menhir_ast, t)) |> Haz3lcore.Exp.fresh); } | Let(p, e1, e2) => Let(Pat.of_menhir_ast(p), of_menhir_ast(e1), of_menhir_ast(e2)) @@ -482,14 +482,24 @@ and Pat: { | IntPat(i) => Int(i) | FloatPat(f) => Float(f) | CastPat(p, t1, t2) => - Cast(of_menhir_ast(p), Typ.of_menhir_ast(t1), Typ.of_menhir_ast(t2)) + Parens( + Cast( + of_menhir_ast(p), + Typ.of_menhir_ast(t1), + Typ.of_menhir_ast(t2), + ) + |> Haz3lcore.Pat.fresh, + ) | VarPat(x) => Var(x) | ConstructorPat(x, ty) => Constructor(x, Typ.of_menhir_ast(ty)) | StringPat(s) => String(s) | TuplePat(pats) => Parens(Tuple(List.map(of_menhir_ast, pats)) |> Haz3lcore.Pat.fresh) | ApPat(pat1, pat2) => Ap(of_menhir_ast(pat1), of_menhir_ast(pat2)) - | ConsPat(p1, p2) => Cons(of_menhir_ast(p1), of_menhir_ast(p2)) + | ConsPat(p1, p2) => + Parens( + Cons(of_menhir_ast(p1), of_menhir_ast(p2)) |> Haz3lcore.Pat.fresh, + ) | BoolPat(b) => Bool(b) | EmptyHolePat => EmptyHole | WildPat => Wild diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 311432f8ed..d574ae2125 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -98,55 +98,15 @@ let menhir_maketerm_equivalent_test = let qcheck_menhir_maketerm_equivalent_test = QCheck.Test.make( ~name="Menhir and maketerm are equivalent", - ~count=100, + ~count=10000, QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(7)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); - // TODO Maybe only do this when necessary. - // TODO Check with Matthew if I'm using this correctly - // Add parens around tuples and parens around certain patterns - // Move this to conversion - let core_exp = - Exp.map_term( - ~f_exp= - (cont, e) => - switch (e.term) { - | Tuple(es) => - Parens(Tuple(es |> List.map(cont)) |> Exp.fresh) - |> Exp.fresh - | _ => cont(e) - }, - ~f_pat= - (cont, e) => - switch (e.term) { - | Tuple(es) => - Parens(Tuple(es |> List.map(cont)) |> Pat.fresh) - |> Pat.fresh - | Cons(p1, p2) => - Parens(Cons(cont(p1), cont(p2)) |> Pat.fresh) |> Pat.fresh - | Cast(p, t1, t2) => - Parens(Cast(cont(p), t1, t2) |> Pat.fresh) |> Pat.fresh - | _ => cont(e) - }, - ~f_typ= - (cont, e) => - switch (e.term) { - | Rec(x, t) => - Parens(Rec(x, cont(t)) |> Typ.fresh) |> Typ.fresh - | Sum(cs) => Parens(Sum(cs) |> Typ.fresh) |> Typ.fresh - | Prod(ts) => Parens(Prod(ts) |> Typ.fresh) |> Typ.fresh - | _ => cont(e) - }, - core_exp, - ); let segment = ExpToSegment.exp_to_segment( ~settings= - ExpToSegment.Settings.of_core( - ~inline=true, // TODO What does inline do? - CoreSettings.off, - ), + ExpToSegment.Settings.of_core(~inline=true, CoreSettings.off), core_exp, ); From 89059bf6fceafebac18302669352d9f8b9123724 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 15:44:23 -0500 Subject: [PATCH 238/281] Reduce test count --- test/Test_Menhir.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index d574ae2125..3a489d7398 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -98,7 +98,7 @@ let menhir_maketerm_equivalent_test = let qcheck_menhir_maketerm_equivalent_test = QCheck.Test.make( ~name="Menhir and maketerm are equivalent", - ~count=10000, + ~count=100, QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(7)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); From c706b4bb37683e0d21ff5cfc0dd2c9984f08bb8c Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 16:19:08 -0500 Subject: [PATCH 239/281] Make tuple types not singleton in parser --- src/haz3lmenhir/AST.re | 3 +-- src/haz3lmenhir/Conversion.re | 2 -- src/haz3lmenhir/Parser.mly | 9 +++++---- 3 files changed, 6 insertions(+), 8 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 3ee02d2aa8..f24c141685 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -87,7 +87,6 @@ type typ = | StringType | FloatType | BoolType - | UnitType | SumTyp(sumtype) | UnknownType(typ_provenance) | TupleType(list(typ)) @@ -446,7 +445,7 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = return(StringType), return(FloatType), return(BoolType), - return(UnitType), + return(TupleType([])), map(x => UnknownType(x), arb_typ_provenance.gen), map(x => SumTyp([Variant(x, None)]), gen_constructor_ident), ]); diff --git a/src/haz3lmenhir/Conversion.re b/src/haz3lmenhir/Conversion.re index f204f5edd0..1941e4be0f 100644 --- a/src/haz3lmenhir/Conversion.re +++ b/src/haz3lmenhir/Conversion.re @@ -370,7 +370,6 @@ and Typ: { | FloatType => Float | BoolType => Bool | StringType => String - | UnitType => Prod([]) | UnknownType(p) => switch (p) { | Internal => Unknown(Internal) @@ -421,7 +420,6 @@ and Typ: { | String => StringType | Bool => BoolType | Var(x) => TypVar(x) - | Prod([]) => UnitType | Prod(ts) => TupleType(List.map(of_core, ts)) | List(t) => ArrayType(of_core(t)) | Arrow(t1, t2) => ArrowType(of_core(t1), of_core(t2)) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 1e63804f44..e9024860a0 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -203,13 +203,13 @@ program: binExp: | e1 = exp; b = binOp; e2 = exp { BinExp (e1, b, e2) } -// Currently singleton tuples are still TupleTypes and we then convert to singleton in Conversion %inline tupleType: - | OPEN_PAREN; types = separated_list(COMMA, typ); CLOSE_PAREN { TupleType(types) } + | OPEN_PAREN; hd = typ; COMMA; types = separated_list(COMMA, typ); CLOSE_PAREN { TupleType(hd :: types) } %inline sumTerm: - | i = CONSTRUCTOR_IDENT; t = tupleType { Variant(i, Some(t)) } + | i = CONSTRUCTOR_IDENT; OPEN_PAREN; hd = typ; COMMA; types = separated_list(COMMA, typ); CLOSE_PAREN { Variant(i, Some(TupleType(hd :: types))) } + | i = CONSTRUCTOR_IDENT; OPEN_PAREN; t = typ; CLOSE_PAREN; { Variant(i, Some(t)) } | i = CONSTRUCTOR_IDENT { Variant(i, None) } | QUESTION { BadEntry(UnknownType(EmptyHole)) } @@ -229,13 +229,14 @@ typ: | STRING_TYPE { StringType } | UNKNOWN; INTERNAL { UnknownType(Internal) } | QUESTION { UnknownType(EmptyHole) } - | UNIT { UnitType } + | UNIT { TupleType([]) } | FORALL; a = tpat; DASH_ARROW; t = typ { ForallType(a, t) } | t = tupleType { t } | OPEN_SQUARE_BRACKET; t = typ; CLOSE_SQUARE_BRACKET { ArrayType(t) } | t1 = typ; DASH_ARROW; t2 = typ { ArrowType(t1, t2) } | s = sumTyp; { SumTyp(s) } | REC; c=tpat; DASH_ARROW; t = typ { RecType(c, t) } + | OPEN_PAREN; t = typ; CLOSE_PAREN { t } nonAscriptingPat: | OPEN_PAREN; p = pat; CLOSE_PAREN { p } From 0990fb150f9b96d08adda5568952da0110c10fb0 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 16:32:28 -0500 Subject: [PATCH 240/281] Stop generating castpat from known types --- src/haz3lmenhir/AST.re | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index f24c141685..898a66a39e 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -577,11 +577,10 @@ and gen_pat_sized: int => QCheck.Gen.t(pat) = ); }, // The parser only handles ApPat with a constructor { - let* p = self((n - 1) / 3); - let* t1 = gen_typ_sized((n - 1) / 3); - let+ t2 = gen_typ_sized((n - 1) / 3); - CastPat(p, t1, t2); - }, + let* p = self((n - 1) / 2); + let+ t1 = gen_typ_sized((n - 1) / 2); + CastPat(p, t1, UnknownType(Internal)); + } // The second cast pat isn't present in syntax ]) }; }, From 0444c5362dfae906c81b6e61d9730ee8de756488 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 17:20:17 -0500 Subject: [PATCH 241/281] Add github issues to comment --- test/Test_Menhir.re | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 3a489d7398..e19e478198 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -135,6 +135,13 @@ let qcheck_menhir_maketerm_equivalent_test = * * TODO This fails due to types not being serialized on constructors * and some other ExpToSegment inconsistencies + * + * Filter and Test not implemented + * Deferral serializing as "deferral" + * Right associated operator + * https://github.com/hazelgrove/hazel/issues/1452 + * https://github.com/hazelgrove/hazel/issues/1451 + * https://github.com/hazelgrove/hazel/issues/1445 */ let qcheck_menhir_serialized_equivalent_test = QCheck.Test.make( From 323eb584f55337715346d1b473521b823eb64743 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 17:21:47 -0500 Subject: [PATCH 242/281] More generator fixes for roundtripping parsing and serialization --- src/haz3lmenhir/AST.re | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 898a66a39e..0742ffbbec 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -107,7 +107,13 @@ type pat = | EmptyHolePat | WildPat | IntPat(int) - | FloatPat(float) + | FloatPat( + [@equal + (a, b) => + Printf.(sprintf("%f", a) == sprintf("%f", b)); + + ] float, + ) | VarPat(string) | ConstructorPat(string, typ) | StringPat(string) @@ -135,7 +141,9 @@ type exp = // This equality condition is used to say that two floats are equal if they are equal in the ExpToSegment serialization ( [@equal - (a, b) => Printf.(sprintf("%.12f", a) == sprintf("%.12f", b)) + (a, b) => { + Printf.(sprintf("%f", a) == sprintf("%f", b)); + } ] float, ) | Var(string) @@ -446,7 +454,7 @@ and gen_typ_sized: int => QCheck.Gen.t(typ) = return(FloatType), return(BoolType), return(TupleType([])), - map(x => UnknownType(x), arb_typ_provenance.gen), + return(UnknownType(EmptyHole)), // Only doing emptyhole because internal doesn't have a distinct representation in ExpToSegment map(x => SumTyp([Variant(x, None)]), gen_constructor_ident), ]); fix( From 3146477db920053a08d82cc19f647be7a408017a Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 17:24:53 -0500 Subject: [PATCH 243/281] Fix equality check in Menhir serialized equivalent test --- test/Test_Menhir.re | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index e19e478198..837ad14bfb 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -163,7 +163,7 @@ let qcheck_menhir_serialized_equivalent_test = let serialized = Printer.of_segment(~holes=Some("?"), segment); let menhir_parsed = Haz3lmenhir.Interface.parse_program(serialized); - menhir_parsed == exp; + AST.equal_exp(menhir_parsed, exp); }, ); @@ -821,7 +821,6 @@ let ex5 = list_of_mylist(x) in ), QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), // Disabled due to bugs in ExpToSegment - // e.g. https://github.com/hazelgrove/hazel/issues/1445 // QCheck_alcotest.to_alcotest(qcheck_menhir_serialized_equivalent_test), ], ); From c06d6c84ca2e33de82e9b1dafaf1200c348f0093 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 17:25:07 -0500 Subject: [PATCH 244/281] Reformat float equality --- src/haz3lmenhir/AST.re | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index 0742ffbbec..aa0bff7916 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -108,11 +108,7 @@ type pat = | WildPat | IntPat(int) | FloatPat( - [@equal - (a, b) => - Printf.(sprintf("%f", a) == sprintf("%f", b)); - - ] float, + [@equal (a, b) => Printf.(sprintf("%f", a) == sprintf("%f", b))] float, ) | VarPat(string) | ConstructorPat(string, typ) @@ -140,11 +136,7 @@ type exp = | Float // This equality condition is used to say that two floats are equal if they are equal in the ExpToSegment serialization ( - [@equal - (a, b) => { - Printf.(sprintf("%f", a) == sprintf("%f", b)); - } - ] float, + [@equal (a, b) => Printf.(sprintf("%f", a) == sprintf("%f", b))] float, ) | Var(string) | Constructor(string, typ) From 02776a788e5e80c2a1aab6c7a4cf9da88f464996 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 17:53:05 -0500 Subject: [PATCH 245/281] Remove todos and precedence fixes --- src/haz3lmenhir/Parser.mly | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index e9024860a0..83df6af129 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -119,9 +119,8 @@ open AST %right DASH_ARROW %nonassoc IF_EXP -%right L_OR // TODO Check with Milan. I moved this to make tests pass. +%right L_OR %right L_AND -%right L_NOT %left GREATER_THAN LESS_THAN DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT DOUBLE_EQUAL_FLOAT STRING_EQUAL @@ -129,22 +128,23 @@ open AST %right CONS %left AT_SYMBOL PLUS MINUS PLUS_FLOAT MINUS_FLOAT -%left DIVIDE TIMES TIMES_FLOAT DIVIDE_FLOAT +%left DIVIDE TIMES TIMES_FLOAT DIVIDE_FLOAT L_NOT %right POWER POWER_FLOAT +%nonassoc UMINUS /* Unary minus (prefix) */ %left COLON %left OPEN_CURLY %left IN -%left DOLLAR_SIGN %nonassoc TYP_AP_SYMBOL %left OPEN_PAREN CLOSE_PAREN +%left DOLLAR_SIGN + %left QUESTION %left TILDE -%nonassoc UMINUS /* Unary minus (prefix) */ @@ -253,10 +253,10 @@ nonAscriptingPat: | s = STRING { StringPat s} | TRUE { BoolPat true} | FALSE {BoolPat false} - | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } // TODO See if we can do multi arg pat ap without extra parens + | f = pat; OPEN_PAREN; a = pat; CLOSE_PAREN { ApPat(f, a) } funPat: - | OPEN_PAREN; p1 = pat; COLON; t1 = typ; CLOSE_PAREN; { CastPat(p1, t1, UnknownType(Internal)) } // TODO Shift/reduce conflict but I'm pretty sure the end parse state is the same either way + | OPEN_PAREN; p1 = pat; COLON; t1 = typ; CLOSE_PAREN; { CastPat(p1, t1, UnknownType(Internal)) } | p = nonAscriptingPat; { p } pat: From 1eb2a56d7ac05093bf8f7cd62df22485e9ec19d3 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 7 Jan 2025 17:53:16 -0500 Subject: [PATCH 246/281] Readd UnOp to generator --- src/haz3lmenhir/AST.re | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/src/haz3lmenhir/AST.re b/src/haz3lmenhir/AST.re index aa0bff7916..4a1ab7c69a 100644 --- a/src/haz3lmenhir/AST.re +++ b/src/haz3lmenhir/AST.re @@ -337,13 +337,11 @@ let rec gen_exp_sized = (n: int): QCheck.Gen.t(exp) => BinExp(e1, op, e2); }, { - // TODO ExpToSegment broken for UnOp - // { - // let* op = gen_op_un; - // let+ e = self((n - 1) / 2); - // UnOp(op, e); - // }, - + let* op = gen_op_un; + let+ e = self((n - 1) / 2); + UnOp(op, e); + }, + { let* e1 = self((n - 1) / 3); let* e2 = self((n - 1) / 3); let+ e3 = self((n - 1) / 3); From 168f5d4ce48eeb312b8a2dbe93622bf83343942a Mon Sep 17 00:00:00 2001 From: Matt Keenan Date: Wed, 8 Jan 2025 09:23:50 -0500 Subject: [PATCH 247/281] prevent unnecessary list traversals --- src/haz3lcore/dynamics/PatternMatch.re | 1 + src/haz3lcore/dynamics/Transition.re | 10 ++++++++-- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/src/haz3lcore/dynamics/PatternMatch.re b/src/haz3lcore/dynamics/PatternMatch.re index 329ca1efd8..2df42583ba 100644 --- a/src/haz3lcore/dynamics/PatternMatch.re +++ b/src/haz3lcore/dynamics/PatternMatch.re @@ -29,6 +29,7 @@ let rec matches = (dp: Pat.t, d: DHExp.t): match_result => | String(s) => let* s' = Unboxing.unbox(String, d); s == s' ? Matches(Environment.empty) : DoesNotMatch; + | Cast({term: ListLit([] as xs), _}, _, _) // Shortcut for empty list pattern match perf | ListLit(xs) => let* s' = Unboxing.unbox(List, d); if (List.length(xs) == List.length(s')) { diff --git a/src/haz3lcore/dynamics/Transition.re b/src/haz3lcore/dynamics/Transition.re index 4dca668399..d46b40f7db 100644 --- a/src/haz3lcore/dynamics/Transition.re +++ b/src/haz3lcore/dynamics/Transition.re @@ -155,12 +155,18 @@ module Transition = (EV: EV_MODE) => { let. _ = otherwise(env, Var(x) |> rewrap); switch (ClosureEnvironment.lookup(env, x)) { | Some(d) => + let is_value = + switch (d |> Exp.term_of) { + | FixF(_, _, _) => false // fixpoints aren't final + | Let(_, _, _) => false // could be mutually-recursive fixpoint + | _ => true // all other closure entries should be final + }; Step({ expr: d |> fast_copy(Id.mk()), state_update, kind: VarLookup, - is_value: false, - }) + is_value, + }); | None => Indet }; | Seq(d1, d2) => From e2b349f7c55d23525e0109156df279bb7cce4c05 Mon Sep 17 00:00:00 2001 From: Matt Keenan Date: Thu, 9 Jan 2025 15:19:28 -0500 Subject: [PATCH 248/281] cleanup: delete uterm, remove statics<-transition dependency --- docs/stepper-and-filter.md | 2 +- src/haz3lcore/dynamics/DHPat.re | 29 ------------- src/haz3lcore/dynamics/EvalCtx.re | 6 +-- src/haz3lcore/dynamics/Evaluator.re | 6 +-- src/haz3lcore/dynamics/Substitution.re | 37 +++++++++++++++-- src/haz3lcore/lang/term/IdTagged.re | 2 +- src/haz3lcore/prog/CachedStatics.re | 4 +- src/haz3lcore/prog/ProgramResult.re | 2 +- src/haz3lcore/statics/Elaborator.re | 22 ++++------ src/haz3lcore/statics/Info.re | 19 ++++----- src/haz3lcore/statics/MakeTerm.re | 32 +++++++------- src/haz3lcore/statics/Statics.re | 46 ++++++++++----------- src/haz3lcore/statics/Term.re | 6 +-- src/haz3lcore/statics/uterm/UExp.re | 1 - src/haz3lcore/statics/uterm/UPat.re | 1 - src/haz3lcore/statics/uterm/UTyp.re | 1 - src/haz3lcore/zipper/Editor.re | 2 +- src/haz3lcore/zipper/EditorUtil.re | 2 +- src/haz3lweb/app/explainthis/ExplainThis.re | 26 ++++++------ src/haz3lweb/debug/DebugConsole.re | 2 +- src/haz3lweb/exercises/Exercise.re | 4 +- src/haz3lweb/exercises/Grading.re | 2 +- src/haz3lweb/exercises/SyntaxTest.re | 10 ++--- src/haz3lweb/util/WorkerServer.re | 4 +- src/haz3lweb/view/ScratchMode.re | 5 --- test/Test_Evaluator.re | 2 +- 26 files changed, 128 insertions(+), 147 deletions(-) delete mode 100644 src/haz3lcore/statics/uterm/UExp.re delete mode 100644 src/haz3lcore/statics/uterm/UPat.re delete mode 100644 src/haz3lcore/statics/uterm/UTyp.re diff --git a/docs/stepper-and-filter.md b/docs/stepper-and-filter.md index d2057fcfda..6c8e19a7ea 100644 --- a/docs/stepper-and-filter.md +++ b/docs/stepper-and-filter.md @@ -109,7 +109,7 @@ program, issue command for change the evaluation mode (big-step or small-step, lazy or eager), and a narrower filter has a higher priority. For the matching part, I choose the Hazel language it's self as the -pattern language. `UPat` and `DHPat` won't work since they only matches +pattern language. `Pat` and `DHPat` won't work since they only matches against *values*, indicating I have to extend them somehow so that they can match against *expressions*. The empty hole is take as the match all filter, i.e. `*` in many other matching languages. It will diff --git a/src/haz3lcore/dynamics/DHPat.re b/src/haz3lcore/dynamics/DHPat.re index 84de439da4..eeb64a200c 100644 --- a/src/haz3lcore/dynamics/DHPat.re +++ b/src/haz3lcore/dynamics/DHPat.re @@ -3,32 +3,3 @@ include Pat; /* A Dynamic Pattern (DHPat) is a pattern that is part of an expression that has been type-checked. Hence why these functions take both a pattern, dp, and an info map, m, with type information. */ - -/** - * Whether dp contains the variable x outside of a hole. - */ -let rec binds_var = (m: Statics.Map.t, x: Var.t, dp: t): bool => - switch (Statics.get_pat_error_at(m, rep_id(dp))) { - | Some(_) => false - | None => - switch (dp |> term_of) { - | EmptyHole - | MultiHole(_) - | Wild - | Invalid(_) - | Int(_) - | Float(_) - | Bool(_) - | String(_) - | Constructor(_) => false - | Cast(y, _, _) - | Parens(y) => binds_var(m, x, y) - | Var(y) => Var.eq(x, y) - | Tuple(dps) => dps |> List.exists(binds_var(m, x)) - | Cons(dp1, dp2) => binds_var(m, x, dp1) || binds_var(m, x, dp2) - | ListLit(d_list) => - let new_list = List.map(binds_var(m, x), d_list); - List.fold_left((||), false, new_list); - | Ap(_, _) => false - } - }; diff --git a/src/haz3lcore/dynamics/EvalCtx.re b/src/haz3lcore/dynamics/EvalCtx.re index 1f60bfa70a..8379753e4b 100644 --- a/src/haz3lcore/dynamics/EvalCtx.re +++ b/src/haz3lcore/dynamics/EvalCtx.re @@ -32,12 +32,12 @@ type term = | Cast(t, Typ.t, Typ.t) | FailedCast(t, Typ.t, Typ.t) | DynamicErrorHole(t, InvalidOperationError.t) - | MatchScrut(t, list((UPat.t, DHExp.t))) + | MatchScrut(t, list((Pat.t, DHExp.t))) | MatchRule( DHExp.t, - UPat.t, + Pat.t, t, - (list((UPat.t, DHExp.t)), list((UPat.t, DHExp.t))), + (list((Pat.t, DHExp.t)), list((Pat.t, DHExp.t))), ) and t = | Mark diff --git a/src/haz3lcore/dynamics/Evaluator.re b/src/haz3lcore/dynamics/Evaluator.re index fc4027f4d6..f756bc6bd9 100644 --- a/src/haz3lcore/dynamics/Evaluator.re +++ b/src/haz3lcore/dynamics/Evaluator.re @@ -114,7 +114,7 @@ let rec evaluate = (state, env, d) => { }; }; -let evaluate' = (env, {d, _}: Elaborator.Elaboration.t) => { +let evaluate' = (env, d: DHExp.t) => { let state = ref(EvaluatorState.init); let env = ClosureEnvironment.of_environment(env); let result = evaluate(state, env, d); @@ -131,9 +131,9 @@ let evaluate = (~settings: CoreSettings.t, ~env=Builtins.env_init, elab: DHExp.t) : ProgramResult.t(ProgramResult.inner) => switch () { - | _ when !settings.dynamics => Off({d: elab}) + | _ when !settings.dynamics => Off(elab) | _ => - switch (evaluate'(env, {d: elab})) { + switch (evaluate'(env, elab)) { | exception (EvaluatorError.Exception(reason)) => print_endline("EvaluatorError:" ++ EvaluatorError.show(reason)); ResultFail(EvaulatorError(reason)); diff --git a/src/haz3lcore/dynamics/Substitution.re b/src/haz3lcore/dynamics/Substitution.re index 5d918e520b..73c46ff6f5 100644 --- a/src/haz3lcore/dynamics/Substitution.re +++ b/src/haz3lcore/dynamics/Substitution.re @@ -1,3 +1,32 @@ +/** + * Whether dp contains the variable x outside of a hole. + */ +let rec binds_var = (m: Statics.Map.t, x: Var.t, dp: DHPat.t): bool => + switch (Statics.get_pat_error_at(m, Pat.rep_id(dp))) { + | Some(_) => false + | None => + switch (dp |> Pat.term_of) { + | EmptyHole + | MultiHole(_) + | Wild + | Invalid(_) + | Int(_) + | Float(_) + | Bool(_) + | String(_) + | Constructor(_) => false + | Cast(y, _, _) + | Parens(y) => binds_var(m, x, y) + | Var(y) => Var.eq(x, y) + | Tuple(dps) => dps |> List.exists(binds_var(m, x)) + | Cons(dp1, dp2) => binds_var(m, x, dp1) || binds_var(m, x, dp2) + | ListLit(d_list) => + let new_list = List.map(binds_var(m, x), d_list); + List.fold_left((||), false, new_list); + | Ap(_, _) => false + } + }; + /* closed substitution [d1/x]d2 */ let rec subst_var = (m, d1: DHExp.t, x: Var.t, d2: DHExp.t): DHExp.t => { let (term, rewrap) = DHExp.unwrap(d2); @@ -21,7 +50,7 @@ let rec subst_var = (m, d1: DHExp.t, x: Var.t, d2: DHExp.t): DHExp.t => { | Let(dp, d3, d4) => let d3 = subst_var(m, d1, x, d3); let d4 = - if (DHPat.binds_var(m, x, dp)) { + if (binds_var(m, x, dp)) { d4; } else { subst_var(m, d1, x, d4); @@ -30,7 +59,7 @@ let rec subst_var = (m, d1: DHExp.t, x: Var.t, d2: DHExp.t): DHExp.t => { | FixF(y, d3, env) => let env' = Option.map(subst_var_env(m, d1, x), env); let d3 = - if (DHPat.binds_var(m, x, y)) { + if (binds_var(m, x, y)) { d3; } else { subst_var(m, d1, x, d3); @@ -40,7 +69,7 @@ let rec subst_var = (m, d1: DHExp.t, x: Var.t, d2: DHExp.t): DHExp.t => { /* Function closure shouldn't appear during substitution (which only is called from elaboration currently) */ let env' = Option.map(subst_var_env(m, d1, x), env); - if (DHPat.binds_var(m, x, dp)) { + if (binds_var(m, x, dp)) { Fun(dp, d3, env', s) |> rewrap; } else { let d3 = subst_var(m, d1, x, d3); @@ -87,7 +116,7 @@ let rec subst_var = (m, d1: DHExp.t, x: Var.t, d2: DHExp.t): DHExp.t => { let rules = List.map( ((p, v)) => - if (DHPat.binds_var(m, x, p)) { + if (binds_var(m, x, p)) { (p, v); } else { (p, subst_var(m, d1, x, v)); diff --git a/src/haz3lcore/lang/term/IdTagged.re b/src/haz3lcore/lang/term/IdTagged.re index 200be8a4ab..1bd91daf80 100644 --- a/src/haz3lcore/lang/term/IdTagged.re +++ b/src/haz3lcore/lang/term/IdTagged.re @@ -5,7 +5,7 @@ type t('a) = { [@show.opaque] ids: list(Id.t), [@show.opaque] - /* UExp invariant: copied should always be false, and the id should be unique + /* Exp invariant: copied should always be false, and the id should be unique DHExp invariant: if copied is true, then this term and its children may not have unique ids. The flag is used to avoid deep-copying expressions during evaluation, while keeping track of where we will need to replace the ids diff --git a/src/haz3lcore/prog/CachedStatics.re b/src/haz3lcore/prog/CachedStatics.re index 106ce24ab0..75d3b81f30 100644 --- a/src/haz3lcore/prog/CachedStatics.re +++ b/src/haz3lcore/prog/CachedStatics.re @@ -2,8 +2,8 @@ open Util; [@deriving (show({with_path: false}), sexp, yojson)] type t = { - term: UExp.t, - elaborated: UExp.t, + term: Exp.t, + elaborated: Exp.t, info_map: Statics.Map.t, error_ids: list(Id.t), }; diff --git a/src/haz3lcore/prog/ProgramResult.re b/src/haz3lcore/prog/ProgramResult.re index fbbb313a08..a45c3a1130 100644 --- a/src/haz3lcore/prog/ProgramResult.re +++ b/src/haz3lcore/prog/ProgramResult.re @@ -40,7 +40,7 @@ type error = [@deriving (show({with_path: false}), sexp, yojson)] type t('a) = - | Off(Elaborator.Elaboration.t) + | Off(DHExp.t) // Elaboration | ResultOk('a) | ResultFail(error) | ResultPending; diff --git a/src/haz3lcore/statics/Elaborator.re b/src/haz3lcore/statics/Elaborator.re index 979a2128c8..b46bc6967f 100644 --- a/src/haz3lcore/statics/Elaborator.re +++ b/src/haz3lcore/statics/Elaborator.re @@ -6,11 +6,6 @@ open Util; exception MissingTypeInfo; -module Elaboration = { - [@deriving (show({with_path: false}), sexp, yojson)] - type t = {d: DHExp.t}; -}; - module ElaborationResult = { [@deriving sexp] type t = @@ -47,7 +42,7 @@ let fresh_pat_cast = (p: DHPat.t, t1: Typ.t, t2: Typ.t): DHPat.t => { }; }; -let elaborated_type = (m: Statics.Map.t, uexp: UExp.t): (Typ.t, Ctx.t, 'a) => { +let elaborated_type = (m: Statics.Map.t, uexp: Exp.t): (Typ.t, Ctx.t, 'a) => { let (mode, self_ty, ctx, co_ctx) = switch (Id.Map.find_opt(Exp.rep_id(uexp), m)) { | Some(Info.InfoExp({mode, ty, ctx, co_ctx, _})) => ( @@ -74,9 +69,9 @@ let elaborated_type = (m: Statics.Map.t, uexp: UExp.t): (Typ.t, Ctx.t, 'a) => { (elab_ty |> Typ.normalize(ctx) |> Typ.all_ids_temp, ctx, co_ctx); }; -let elaborated_pat_type = (m: Statics.Map.t, upat: UPat.t): (Typ.t, Ctx.t) => { +let elaborated_pat_type = (m: Statics.Map.t, upat: Pat.t): (Typ.t, Ctx.t) => { let (mode, self_ty, ctx, prev_synswitch) = - switch (Id.Map.find_opt(UPat.rep_id(upat), m)) { + switch (Id.Map.find_opt(Pat.rep_id(upat), m)) { | Some(Info.InfoPat({mode, ty, ctx, prev_synswitch, _})) => ( mode, ty, @@ -104,11 +99,10 @@ let elaborated_pat_type = (m: Statics.Map.t, upat: UPat.t): (Typ.t, Ctx.t) => { (elab_ty |> Typ.normalize(ctx) |> Typ.all_ids_temp, ctx); }; -let rec elaborate_pattern = - (m: Statics.Map.t, upat: UPat.t): (DHPat.t, Typ.t) => { +let rec elaborate_pattern = (m: Statics.Map.t, upat: Pat.t): (DHPat.t, Typ.t) => { let (elaborated_type, ctx) = elaborated_pat_type(m, upat); let cast_from = (ty, exp) => fresh_pat_cast(exp, ty, elaborated_type); - let (term, rewrap) = UPat.unwrap(upat); + let (term, rewrap) = Pat.unwrap(upat); let dpat = switch (term) { | Int(_) => upat |> cast_from(Int |> Typ.temp) @@ -203,10 +197,10 @@ let rec elaborate_pattern = [Matt] A lot of these fresh_cast calls are redundant, however if you want to remove one, I'd ask you instead comment it out and leave a comment explaining why it's redundant. */ -let rec elaborate = (m: Statics.Map.t, uexp: UExp.t): (DHExp.t, Typ.t) => { +let rec elaborate = (m: Statics.Map.t, uexp: Exp.t): (DHExp.t, Typ.t) => { let (elaborated_type, ctx, co_ctx) = elaborated_type(m, uexp); let cast_from = (ty, exp) => fresh_cast(exp, ty, elaborated_type); - let (term, rewrap) = UExp.unwrap(uexp); + let (term, rewrap) = Exp.unwrap(uexp); let dhexp = switch (term) { | Invalid(_) @@ -565,7 +559,7 @@ let rec elaborate = (m: Statics.Map.t, uexp: UExp.t): (DHExp.t, Typ.t) => { let fix_typ_ids = Exp.map_term(~f_typ=(cont, e) => e |> IdTagged.new_ids |> cont); -let uexp_elab = (m: Statics.Map.t, uexp: UExp.t): ElaborationResult.t => +let uexp_elab = (m: Statics.Map.t, uexp: Exp.t): ElaborationResult.t => switch (elaborate(m, uexp)) { | exception MissingTypeInfo => DoesNotElaborate | (d, ty) => Elaborates(d |> fix_typ_ids, ty, Delta.empty) diff --git a/src/haz3lcore/statics/Info.re b/src/haz3lcore/statics/Info.re index 8aaaeaae3d..e8769ac892 100644 --- a/src/haz3lcore/statics/Info.re +++ b/src/haz3lcore/statics/Info.re @@ -192,7 +192,7 @@ type status_tpat = [@deriving (show({with_path: false}), sexp, yojson)] type exp = { - term: UExp.t, /* The term under consideration */ + term: Exp.t, /* The term under consideration */ ancestors, /* Ascending list of containing term ids */ ctx: Ctx.t, /* Typing context for the term */ mode: Mode.t, /* Parental type expectations */ @@ -205,7 +205,7 @@ type exp = { [@deriving (show({with_path: false}), sexp, yojson)] type pat = { - term: UPat.t, + term: Pat.t, ancestors, ctx: Ctx.t, co_ctx: CoCtx.t, @@ -585,7 +585,7 @@ let fixed_typ_pat = (ctx, mode: Mode.t, self: Self.pat): Typ.t => { let fixed_constraint_pat = ( - upat: UPat.t, + upat: Pat.t, ctx, mode: Mode.t, self: Self.pat, @@ -609,9 +609,8 @@ let fixed_typ_exp = (ctx, mode: Mode.t, self: Self.exp): Typ.t => }; /* Add derivable attributes for expression terms */ -let derived_exp = - (~uexp: UExp.t, ~ctx, ~mode, ~ancestors, ~self, ~co_ctx): exp => { - let cls = Cls.Exp(UExp.cls_of_term(uexp.term)); +let derived_exp = (~uexp: Exp.t, ~ctx, ~mode, ~ancestors, ~self, ~co_ctx): exp => { + let cls = Cls.Exp(Exp.cls_of_term(uexp.term)); let status = status_exp(ctx, mode, self); let ty = fixed_typ_exp(ctx, mode, self); {cls, self, ty, mode, status, ctx, co_ctx, ancestors, term: uexp}; @@ -620,7 +619,7 @@ let derived_exp = /* Add derivable attributes for pattern terms */ let derived_pat = ( - ~upat: UPat.t, + ~upat: Pat.t, ~ctx, ~co_ctx, ~prev_synswitch, @@ -630,7 +629,7 @@ let derived_pat = ~constraint_, ) : pat => { - let cls = Cls.Pat(UPat.cls_of_term(upat.term)); + let cls = Cls.Pat(Pat.cls_of_term(upat.term)); let status = status_pat(ctx, mode, self); let ty = fixed_typ_pat(ctx, mode, self); let constraint_ = fixed_constraint_pat(upat, ctx, mode, self, constraint_); @@ -650,10 +649,10 @@ let derived_pat = }; /* Add derivable attributes for types */ -let derived_typ = (~utyp: UTyp.t, ~ctx, ~ancestors, ~expects): typ => { +let derived_typ = (~utyp: Typ.t, ~ctx, ~ancestors, ~expects): typ => { let cls: Cls.t = /* Hack to improve CI display */ - switch (expects, UTyp.cls_of_term(utyp.term)) { + switch (expects, Typ.cls_of_term(utyp.term)) { | (VariantExpected(_) | ConstructorExpected(_), Var) => Cls.Typ(Constructor) | (_, cls) => Cls.Typ(cls) diff --git a/src/haz3lcore/statics/MakeTerm.re b/src/haz3lcore/statics/MakeTerm.re index 06f5786879..9c28029e00 100644 --- a/src/haz3lcore/statics/MakeTerm.re +++ b/src/haz3lcore/statics/MakeTerm.re @@ -36,7 +36,7 @@ type unsorted = | Bin(t, tiles, t); type t = { - term: UExp.t, + term: Exp.t, terms: TermMap.t, projectors: Id.Map.t(Piece.projector), }; @@ -58,7 +58,7 @@ let is_typ_bsum = is_nary(Any.is_typ, "+"); let is_grout = tiles => Aba.get_as(tiles) |> List.map(snd) |> List.for_all((==)(([" "], []))); -let is_rules = ((ts, kids): tiles): option(Aba.t(UPat.t, UExp.t)) => { +let is_rules = ((ts, kids): tiles): option(Aba.t(Pat.t, Exp.t)) => { open OptUtil.Syntax; let+ ps = (ts: list(tile)) @@ -124,7 +124,7 @@ let rm_and_log_projectors = (seg: Segment.t): Segment.t => seg, ); -let parse_sum_term: UTyp.t => ConstructorMap.variant(UTyp.t) = +let parse_sum_term: Typ.t => ConstructorMap.variant(Typ.t) = fun | {term: Var(ctr), ids, _} => Variant(ctr, ids, None) | {term: Ap({term: Var(ctr), ids: ids_ctr, _}, u), ids: ids_ap, _} => @@ -170,9 +170,9 @@ and exp = unsorted => { let ids = ids(unsorted) @ inner_ids; return(e => Exp(e), ids, {ids, copied: false, term}); } -and exp_term: unsorted => (UExp.term, list(Id.t)) = { - let ret = (tm: UExp.term) => (tm, []); - let hole = unsorted => UExp.hole(kids_of_unsorted(unsorted)); +and exp_term: unsorted => (Exp.term, list(Id.t)) = { + let ret = (tm: Exp.term) => (tm, []); + let hole = unsorted => Exp.hole(kids_of_unsorted(unsorted)); fun | Op(tiles) as tm => switch (tiles) { @@ -250,19 +250,19 @@ and exp_term: unsorted => (UExp.term, list(Id.t)) = { ), ) | (["(", ")"], [Exp(arg)]) => - let use_deferral = (arg: UExp.t): UExp.t => { + let use_deferral = (arg: Exp.t): Exp.t => { ids: arg.ids, copied: false, term: Deferral(InAp), }; switch (arg.term) { - | _ when UExp.is_deferral(arg) => + | _ when Exp.is_deferral(arg) => ret(DeferredAp(l, [use_deferral(arg)])) - | Tuple(es) when List.exists(UExp.is_deferral, es) => ( + | Tuple(es) when List.exists(Exp.is_deferral, es) => ( DeferredAp( l, List.map( - arg => UExp.is_deferral(arg) ? use_deferral(arg) : arg, + arg => Exp.is_deferral(arg) ? use_deferral(arg) : arg, es, ), ), @@ -332,9 +332,9 @@ and pat = unsorted => { let ids = ids(unsorted) @ inner_ids; return(p => Pat(p), ids, {ids, term, copied: false}); } -and pat_term: unsorted => (UPat.term, list(Id.t)) = { - let ret = (term: UPat.term) => (term, []); - let hole = unsorted => UPat.hole(kids_of_unsorted(unsorted)); +and pat_term: unsorted => (Pat.term, list(Id.t)) = { + let ret = (term: Pat.term) => (term, []); + let hole = unsorted => Pat.hole(kids_of_unsorted(unsorted)); fun | Op(tiles) as tm => switch (tiles) { @@ -398,9 +398,9 @@ and typ = unsorted => { let ids = ids(unsorted) @ inner_ids; return(ty => Typ(ty), ids, {ids, term, copied: false}); } -and typ_term: unsorted => (UTyp.term, list(Id.t)) = { - let ret = (term: UTyp.term) => (term, []); - let hole = unsorted => UTyp.hole(kids_of_unsorted(unsorted)); +and typ_term: unsorted => (Typ.term, list(Id.t)) = { + let ret = (term: Typ.term) => (term, []); + let hole = unsorted => Typ.hole(kids_of_unsorted(unsorted)); fun | Op(tiles) as tm => switch (tiles) { diff --git a/src/haz3lcore/statics/Statics.re b/src/haz3lcore/statics/Statics.re index 4818a4aaf8..7165db11d8 100644 --- a/src/haz3lcore/statics/Statics.re +++ b/src/haz3lcore/statics/Statics.re @@ -172,7 +172,7 @@ and uexp_to_info_map = ~mode=Mode.Syn, ~is_in_filter=false, ~ancestors, - {ids, copied: _, term} as uexp: UExp.t, + {ids, copied: _, term} as uexp: Exp.t, m: Map.t, ) : (Info.exp, Map.t) => { @@ -188,14 +188,14 @@ and uexp_to_info_map = (info, add_info(ids, InfoExp(info), m)); }; let add = (~self, ~co_ctx, m) => add'(~self=Common(self), ~co_ctx, m); - let ancestors = [UExp.rep_id(uexp)] @ ancestors; + let ancestors = [Exp.rep_id(uexp)] @ ancestors; let uexp_to_info_map = ( ~ctx, ~mode=Mode.Syn, ~is_in_filter=is_in_filter, ~ancestors=ancestors, - uexp: UExp.t, + uexp: Exp.t, m: Map.t, ) => { uexp_to_info_map(~ctx, ~mode, ~is_in_filter, ~ancestors, uexp, m); @@ -234,7 +234,7 @@ and uexp_to_info_map = | Float(_) => atomic(Just(Float |> Typ.temp)) | String(_) => atomic(Just(String |> Typ.temp)) | ListLit(es) => - let ids = List.map(UExp.rep_id, es); + let ids = List.map(Exp.rep_id, es); let modes = Mode.of_list_lit(ctx, List.length(es), mode); let (es, m) = map_m_go(m, modes, es); let tys = List.map(Info.exp_ty, es); @@ -254,7 +254,7 @@ and uexp_to_info_map = ); | ListConcat(e1, e2) => let mode = Mode.of_list_concat(ctx, mode); - let ids = List.map(UExp.rep_id, [e1, e2]); + let ids = List.map(Exp.rep_id, [e1, e2]); let (e1, m) = go(~mode, e1, m); let (e2, m) = go(~mode, e2, m); add( @@ -265,7 +265,7 @@ and uexp_to_info_map = | Var(name) => add'( ~self=Self.of_exp_var(ctx, name), - ~co_ctx=CoCtx.singleton(name, UExp.rep_id(uexp), Mode.ty_of(mode)), + ~co_ctx=CoCtx.singleton(name, Exp.rep_id(uexp), Mode.ty_of(mode)), m, ) | DynamicErrorHole(e, _) @@ -273,7 +273,7 @@ and uexp_to_info_map = let (e, m) = go(~mode, e, m); add(~self=Just(e.ty), ~co_ctx=e.co_ctx, m); | UnOp(Meta(Unquote), e) when is_in_filter => - let e: UExp.t = { + let e: Exp.t = { ids: e.ids, copied: false, term: @@ -330,7 +330,7 @@ and uexp_to_info_map = add(~self=Just(e2.ty), ~co_ctx=CoCtx.union([e1.co_ctx, e2.co_ctx]), m); | Constructor(ctr, _) => atomic(Self.of_ctr(ctx, ctr)) | Ap(_, fn, arg) => - let fn_mode = Mode.of_ap(ctx, mode, UExp.ctr_name(fn)); + let fn_mode = Mode.of_ap(ctx, mode, Exp.ctr_name(fn)); let (fn, m) = go(~mode=fn_mode, fn, m); let (ty_in, ty_out) = Typ.matched_arrow(ctx, fn.ty); let (arg, m) = go(~mode=Ana(ty_in), arg, m); @@ -350,7 +350,7 @@ and uexp_to_info_map = | None => add(~self=Just(ty_body), ~co_ctx=fn.co_ctx, m) /* invalid name matches with no free type variables. */ }; | DeferredAp(fn, args) => - let fn_mode = Mode.of_ap(ctx, mode, UExp.ctr_name(fn)); + let fn_mode = Mode.of_ap(ctx, mode, Exp.ctr_name(fn)); let (fn, m) = go(~mode=fn_mode, fn, m); let (ty_in, ty_out) = Typ.matched_arrow(ctx, fn.ty); let num_args = List.length(args); @@ -478,7 +478,7 @@ and uexp_to_info_map = m, ); | If(e0, e1, e2) => - let branch_ids = List.map(UExp.rep_id, [e1, e2]); + let branch_ids = List.map(Exp.rep_id, [e1, e2]); let (cond, m) = go(~mode=Ana(Bool |> Typ.temp), e0, m); let (cons, m) = go(~mode, e1, m); let (alt, m) = go(~mode, e2, m); @@ -490,7 +490,7 @@ and uexp_to_info_map = | Match(scrut, rules) => let (scrut, m) = go(~mode=Syn, scrut, m); let (ps, es) = List.split(rules); - let branch_ids = List.map(UExp.rep_id, es); + let branch_ids = List.map(Exp.rep_id, es); let (ps', _) = map_m( go_pat( @@ -527,7 +527,7 @@ and uexp_to_info_map = let (self, m) = switch (constraint_ty) { | Some(constraint_ty) => - let pats_to_info_map = (ps: list(UPat.t), m) => { + let pats_to_info_map = (ps: list(Pat.t), m) => { /* Add co-ctxs to patterns */ List.fold_left( ((m, acc_constraint), (p, co_ctx)) => { @@ -604,7 +604,7 @@ and uexp_to_info_map = switch (typat.term) { | Var(name) when !Ctx.shadows_typ(ctx, name) => /* Currently we disallow all type shadowing */ - /* NOTE(andrew): Currently, UTyp.to_typ returns Unknown(TypeHole) + /* NOTE(andrew): Currently, Typ.to_typ returns Unknown(TypeHole) for any type variable reference not in its ctx. So any free variables in the definition would be obliterated. But we need to check for free variables to decide whether to make a recursive type or not. So we @@ -636,14 +636,14 @@ and uexp_to_info_map = // (ty_rec, ctx_def, ctx_def); // } // : { - // let ty = Term.UTyp.to_typ(ctx, utyp); + // let ty = Term.Typ.to_typ(ctx, utyp); // (ty, ctx, Ctx.add_alias(ctx, name, utpat_id(typat), ty)); // }; }; }; let ctx_body = switch (Typ.get_sum_constructors(ctx, ty_def)) { - | Some(sm) => Ctx.add_ctrs(ctx_body, name, UTyp.rep_id(utyp), sm) + | Some(sm) => Ctx.add_ctrs(ctx_body, name, Typ.rep_id(utyp), sm) | None => ctx_body }; let ({co_ctx, ty: ty_body, _}: Info.exp, m) = @@ -670,7 +670,7 @@ and upat_to_info_map = ~co_ctx, ~ancestors: Info.ancestors, ~mode: Mode.t=Mode.Syn, - {ids, term, _} as upat: UPat.t, + {ids, term, _} as upat: Pat.t, m: Map.t, ) : (Info.pat, Map.t) => { @@ -696,7 +696,7 @@ and upat_to_info_map = (info, add_info(ids, InfoPat(info), m)); }; let atomic = (self, constraint_) => add(~self, ~ctx, ~constraint_, m); - let ancestors = [UPat.rep_id(upat)] @ ancestors; + let ancestors = [Pat.rep_id(upat)] @ ancestors; let go = upat_to_info_map(~is_synswitch, ~ancestors, ~co_ctx); let unknown = Unknown(is_synswitch ? SynSwitch : Internal) |> Typ.temp; let ctx_fold = (ctx: Ctx.t, m) => @@ -734,7 +734,7 @@ and upat_to_info_map = | String(string) => atomic(Just(String |> Typ.temp), Constraint.String(string)) | ListLit(ps) => - let ids = List.map(UPat.rep_id, ps); + let ids = List.map(Pat.rep_id, ps); let modes = Mode.of_list_lit(ctx, List.length(ps), mode); let (ctx, tys, cons, m) = ctx_fold(ctx, m, ps, modes); let rec cons_fold_list = cs => @@ -771,7 +771,7 @@ and upat_to_info_map = mode, Common(Just(Unknown(Internal) |> Typ.temp)), ); - let entry = Ctx.VarEntry({name, id: UPat.rep_id(upat), typ: ctx_typ}); + let entry = Ctx.VarEntry({name, id: Pat.rep_id(upat), typ: ctx_typ}); add( ~self=Just(unknown), ~ctx=Ctx.extend(ctx, entry), @@ -800,7 +800,7 @@ and upat_to_info_map = let self = Self.of_ctr(ctx, ctr); atomic(self, Constraint.of_ctr(ctx, mode, ctr, self)); | Ap(fn, arg) => - let ctr = UPat.ctr_name(fn); + let ctr = Pat.ctr_name(fn); let fn_mode = Mode.of_ap(ctx, mode, ctr); let (fn, m) = go(~ctx, ~mode=fn_mode, fn, m); let (ty_in, ty_out) = Typ.matched_arrow(ctx, fn.ty); @@ -823,7 +823,7 @@ and utyp_to_info_map = ~ctx, ~expects=Info.TypeExpected, ~ancestors, - {ids, term, _} as utyp: UTyp.t, + {ids, term, _} as utyp: Typ.t, m: Map.t, ) : (Info.typ, Map.t) => { @@ -831,7 +831,7 @@ and utyp_to_info_map = let info = Info.derived_typ(~utyp, ~ctx, ~ancestors, ~expects); (info, add_info(ids, InfoTyp(info), m)); }; - let ancestors = [UTyp.rep_id(utyp)] @ ancestors; + let ancestors = [Typ.rep_id(utyp)] @ ancestors; let go' = utyp_to_info_map(~ctx, ~ancestors); let go = go'(~expects=TypeExpected); switch (term) { @@ -942,7 +942,7 @@ and variant_to_info_map = ~ancestors, ~ty_sum, (m, ctrs), - uty: ConstructorMap.variant(UTyp.t), + uty: ConstructorMap.variant(Typ.t), ) => { let go = expects => utyp_to_info_map(~ctx, ~ancestors, ~expects); switch (uty) { diff --git a/src/haz3lcore/statics/Term.re b/src/haz3lcore/statics/Term.re index 5677278b67..b19a5c73a5 100644 --- a/src/haz3lcore/statics/Term.re +++ b/src/haz3lcore/statics/Term.re @@ -100,7 +100,7 @@ module Pat = { switch (pat.term) { | Parens(pat) => is_fun_var(pat) | Cast(pat, typ, _) => - is_var(pat) && (UTyp.is_arrow(typ) || Typ.is_forall(typ)) + is_var(pat) && (Typ.is_arrow(typ) || Typ.is_forall(typ)) | Invalid(_) | EmptyHole | MultiHole(_) @@ -189,7 +189,7 @@ module Pat = { switch (pat.term) { | Parens(pat) => get_fun_var(pat) | Cast(pat, t1, _) => - if (Typ.is_arrow(t1) || UTyp.is_forall(t1)) { + if (Typ.is_arrow(t1) || Typ.is_forall(t1)) { get_var(pat) |> Option.map(var => var); } else { None; @@ -791,7 +791,7 @@ module Rul = { let rep_id = (~any_ids, tm) => switch (ids(~any_ids, tm)) { - | [] => raise(Invalid_argument("UExp.rep_id")) + | [] => raise(Invalid_argument("Exp.rep_id")) | [id, ..._] => id }; }; diff --git a/src/haz3lcore/statics/uterm/UExp.re b/src/haz3lcore/statics/uterm/UExp.re deleted file mode 100644 index 16d6db0412..0000000000 --- a/src/haz3lcore/statics/uterm/UExp.re +++ /dev/null @@ -1 +0,0 @@ -include Exp; diff --git a/src/haz3lcore/statics/uterm/UPat.re b/src/haz3lcore/statics/uterm/UPat.re deleted file mode 100644 index 9bd15c6ba8..0000000000 --- a/src/haz3lcore/statics/uterm/UPat.re +++ /dev/null @@ -1 +0,0 @@ -include Pat; diff --git a/src/haz3lcore/statics/uterm/UTyp.re b/src/haz3lcore/statics/uterm/UTyp.re deleted file mode 100644 index 7dcfba5350..0000000000 --- a/src/haz3lcore/statics/uterm/UTyp.re +++ /dev/null @@ -1 +0,0 @@ -include Typ; diff --git a/src/haz3lcore/zipper/Editor.re b/src/haz3lcore/zipper/Editor.re index 819ae28bf3..71d5442963 100644 --- a/src/haz3lcore/zipper/Editor.re +++ b/src/haz3lcore/zipper/Editor.re @@ -8,7 +8,7 @@ module CachedSyntax = { tiles: TileMap.t, holes: list(Grout.t), selection_ids: list(Id.t), - term: UExp.t, + term: Exp.t, /* This term, and the term-derived data structured below, may differ * from the term used for semantics. These terms are identical when * the backpack is empty. If the backpack is non-empty, then when we diff --git a/src/haz3lcore/zipper/EditorUtil.re b/src/haz3lcore/zipper/EditorUtil.re index bcc3a1aa5d..a7225fe7c8 100644 --- a/src/haz3lcore/zipper/EditorUtil.re +++ b/src/haz3lcore/zipper/EditorUtil.re @@ -47,7 +47,7 @@ let rec append_exp = (e1: Exp.t, e2: Exp.t): Exp.t => { }; }; -let wrap_filter = (act: FilterAction.action, term: UExp.t): UExp.t => { +let wrap_filter = (act: FilterAction.action, term: Exp.t): Exp.t => { term: Filter( Filter({ diff --git a/src/haz3lweb/app/explainthis/ExplainThis.re b/src/haz3lweb/app/explainthis/ExplainThis.re index 8a499ee881..3388bbb3ba 100644 --- a/src/haz3lweb/app/explainthis/ExplainThis.re +++ b/src/haz3lweb/app/explainthis/ExplainThis.re @@ -1576,15 +1576,15 @@ let get_doc = | FixF(pat, body, _) => message_single( FixFExp.single( - ~pat_id=UPat.rep_id(pat), - ~body_id=UExp.rep_id(body), + ~pat_id=Pat.rep_id(pat), + ~body_id=Exp.rep_id(body), ), ) | Ap(Reverse, arg, fn) => message_single( PipelineExp.single( - ~arg_id=UExp.rep_id(arg), - ~fn_id=UExp.rep_id(fn), + ~arg_id=Exp.rep_id(arg), + ~fn_id=Exp.rep_id(fn), ), ) | TypAp(f, typ) => @@ -1721,29 +1721,29 @@ let get_doc = | Filter(Filter({act: (Step, One), pat}), body) => message_single( FilterExp.filter_pause( - ~p_id=UExp.rep_id(pat), - ~body_id=UExp.rep_id(body), + ~p_id=Exp.rep_id(pat), + ~body_id=Exp.rep_id(body), ), ) | Filter(Filter({act: (Step, All), pat}), body) => message_single( FilterExp.filter_debug( - ~p_id=UExp.rep_id(pat), - ~body_id=UExp.rep_id(body), + ~p_id=Exp.rep_id(pat), + ~body_id=Exp.rep_id(body), ), ) | Filter(Filter({act: (Eval, All), pat}), body) => message_single( FilterExp.filter_eval( - ~p_id=UExp.rep_id(pat), - ~body_id=UExp.rep_id(body), + ~p_id=Exp.rep_id(pat), + ~body_id=Exp.rep_id(body), ), ) | Filter(Filter({act: (Eval, One), pat}), body) => message_single( FilterExp.filter_hide( - ~p_id=UExp.rep_id(pat), - ~body_id=UExp.rep_id(body), + ~p_id=Exp.rep_id(pat), + ~body_id=Exp.rep_id(body), ), ) | Filter(_) => simple("Internal expression") @@ -1825,7 +1825,7 @@ let get_doc = OpExp.int_un_minus, ); | Meta(Unquote) => - message_single(FilterExp.unquote(~sel_id=UExp.rep_id(exp))) + message_single(FilterExp.unquote(~sel_id=Exp.rep_id(exp))) } | BinOp(op, left, right) => open OpExp; diff --git a/src/haz3lweb/debug/DebugConsole.re b/src/haz3lweb/debug/DebugConsole.re index 3a93554eb3..47e0883cc8 100644 --- a/src/haz3lweb/debug/DebugConsole.re +++ b/src/haz3lweb/debug/DebugConsole.re @@ -14,7 +14,7 @@ let print = switch (key) { | "F1" => zipper |> Zipper.show |> print | "F2" => zipper |> Zipper.unselect_and_zip |> Segment.show |> print - | "F3" => term |> UExp.show |> print + | "F3" => term |> Exp.show |> print | "F4" => map |> Statics.Map.show |> print | "F5" => let env_init = Builtins.env_init; diff --git a/src/haz3lweb/exercises/Exercise.re b/src/haz3lweb/exercises/Exercise.re index 613d0d47be..c1eb9ca2b8 100644 --- a/src/haz3lweb/exercises/Exercise.re +++ b/src/haz3lweb/exercises/Exercise.re @@ -419,7 +419,7 @@ let put_stitched = (pos, s: stitched('a), x: 'a): stitched('a) => | HiddenTests => {...s, hidden_tests: x} }; -let wrap_filter = (act: FilterAction.action, term: UExp.t): UExp.t => { +let wrap_filter = (act: FilterAction.action, term: Exp.t): Exp.t => { term: Filter( Filter({ @@ -438,7 +438,7 @@ let wrap_filter = (act: FilterAction.action, term: UExp.t): UExp.t => { let wrap = (term, editor: Editor.t): TermItem.t => {term, editor}; -let term_of = (editor: Editor.t): UExp.t => +let term_of = (editor: Editor.t): Exp.t => MakeTerm.from_zip_for_sem(editor.state.zipper).term; let stitch3 = (ed1: Editor.t, ed2: Editor.t, ed3: Editor.t) => diff --git a/src/haz3lweb/exercises/Grading.re b/src/haz3lweb/exercises/Grading.re index d3256e427e..16bb554aca 100644 --- a/src/haz3lweb/exercises/Grading.re +++ b/src/haz3lweb/exercises/Grading.re @@ -356,7 +356,7 @@ module MutationTestingReport = { // |> Zipper.zip // |> MakeTerm.go // |> fst - // |> UExp.show + // |> Exp.show // |> print_endline // |> (_ => Virtual_dom.Vdom.Effect.Ignore); diff --git a/src/haz3lweb/exercises/SyntaxTest.re b/src/haz3lweb/exercises/SyntaxTest.re index 23dff72251..9465ac6abf 100644 --- a/src/haz3lweb/exercises/SyntaxTest.re +++ b/src/haz3lweb/exercises/SyntaxTest.re @@ -44,8 +44,7 @@ let rec find_var_upat = (name: string, upat: Pat.t): bool => { if name="a", then l=[fun x -> x+1] */ let rec find_in_let = - (name: string, upat: UPat.t, def: UExp.t, l: list(UExp.t)) - : list(UExp.t) => { + (name: string, upat: Pat.t, def: Exp.t, l: list(Exp.t)): list(Exp.t) => { switch (upat.term, def.term) { | (Parens(up), Parens(ue)) => find_in_let(name, up, ue, l) | (Parens(up), _) => find_in_let(name, up, def, l) @@ -80,8 +79,7 @@ let rec find_in_let = /* Find any function expressions in uexp that are bound to variable name */ -let rec find_fn = - (name: string, uexp: UExp.t, l: list(UExp.t)): list(UExp.t) => { +let rec find_fn = (name: string, uexp: Exp.t, l: list(Exp.t)): list(Exp.t) => { switch (uexp.term) { | Let(up, def, body) => l |> find_in_let(name, up, def) |> find_fn(name, body) @@ -378,7 +376,7 @@ let rec tail_check = (name: string, uexp: Exp.t): bool => { /* Check whether all functions bound to variable name are tail recursive. */ -let is_tail_recursive = (name: string, uexp: UExp.t): bool => { +let is_tail_recursive = (name: string, uexp: Exp.t): bool => { let fn_bodies = [] |> find_fn(name, uexp); if (List.length(fn_bodies) == 0) { false; @@ -391,7 +389,7 @@ let is_tail_recursive = (name: string, uexp: UExp.t): bool => { }; }; -let check = (uexp: UExp.t, predicates: list(UExp.t => bool)): syntax_result => { +let check = (uexp: Exp.t, predicates: list(Exp.t => bool)): syntax_result => { let results = List.map(pred => {uexp |> pred}, predicates); let length = List.length(predicates); let passing = Util.ListUtil.count_pred(res => res, results); diff --git a/src/haz3lweb/util/WorkerServer.re b/src/haz3lweb/util/WorkerServer.re index 8c988d7a51..d3a745c63d 100644 --- a/src/haz3lweb/util/WorkerServer.re +++ b/src/haz3lweb/util/WorkerServer.re @@ -28,9 +28,7 @@ module Response = { }; let work = (res: Request.value): Response.value => - switch ( - Haz3lcore.Evaluator.evaluate'(Haz3lcore.Builtins.env_init, {d: res}) - ) { + switch (Haz3lcore.Evaluator.evaluate'(Haz3lcore.Builtins.env_init, res)) { | exception (Haz3lcore.EvaluatorError.Exception(reason)) => print_endline( "EvaluatorError:" ++ Haz3lcore.EvaluatorError.show(reason), diff --git a/src/haz3lweb/view/ScratchMode.re b/src/haz3lweb/view/ScratchMode.re index 39b1ee511a..8e922aae72 100644 --- a/src/haz3lweb/view/ScratchMode.re +++ b/src/haz3lweb/view/ScratchMode.re @@ -10,11 +10,6 @@ module Model = { scratchpads: list((string, CellEditor.Model.t)), }; - let get_spliced_elabs = model => { - let (key, ed) = List.nth(model.scratchpads, model.current); - [(key, Elaborator.Elaboration.{d: ed.editor.statics.term})]; - }; - [@deriving (show({with_path: false}), sexp, yojson)] type persistent = (int, list((string, CellEditor.Model.persistent))); diff --git a/test/Test_Evaluator.re b/test/Test_Evaluator.re index d9f8d1d50d..ae152ccace 100644 --- a/test/Test_Evaluator.re +++ b/test/Test_Evaluator.re @@ -8,7 +8,7 @@ let evaluation_test = (msg, expected, unevaluated) => msg, expected, ProgramResult.Result.unbox( - snd(Evaluator.evaluate'(Builtins.env_init, {d: unevaluated})), + snd(Evaluator.evaluate'(Builtins.env_init, unevaluated)), ), ); From 2bda1f726bc44358997f21b8a063753284318770 Mon Sep 17 00:00:00 2001 From: disconcision Date: Mon, 13 Jan 2025 21:24:26 -0500 Subject: [PATCH 249/281] incorporate probe projector offside view into projectors API --- src/haz3lcore/zipper/ProjectorBase.re | 37 +++++++++++---- .../zipper/projectors/CheckboxProj.re | 1 + src/haz3lcore/zipper/projectors/FoldProj.re | 1 + src/haz3lcore/zipper/projectors/InfoProj.re | 1 + src/haz3lcore/zipper/projectors/ProbeProj.re | 19 ++++---- .../zipper/projectors/SliderFProj.re | 1 + src/haz3lcore/zipper/projectors/SliderProj.re | 1 + .../zipper/projectors/TextAreaProj.re | 1 + src/haz3lweb/app/common/ProjectorView.re | 46 ++++++++++++------- src/haz3lweb/app/inspector/ProjectorPanel.re | 22 +++++++-- src/haz3lweb/www/style/cursor-inspector.css | 20 ++++---- src/haz3lweb/www/style/projectors/probe.css | 4 +- 12 files changed, 104 insertions(+), 50 deletions(-) diff --git a/src/haz3lcore/zipper/ProjectorBase.re b/src/haz3lcore/zipper/ProjectorBase.re index a6619b613b..b267ff24e7 100644 --- a/src/haz3lcore/zipper/ProjectorBase.re +++ b/src/haz3lcore/zipper/ProjectorBase.re @@ -36,10 +36,6 @@ type utility = { /* The current font metrics for the editor, usable * to coordinate with the parent coordinate grid */ font_metrics: FontMetrics.t, - /* X position in pixels of the end of the row where - * where the projector starts; usable to position part - * of the projector UI at the end of the row */ - offside_offset: float, /* Non-interactive view for segments, included here * because of cyclic dependency issues*/ view: (Sort.t, Base.segment) => Node.t, @@ -86,15 +82,15 @@ module type Projector = { * is pressed when the caret is to the immediate * right/left of the projector */ let can_focus: bool; + /* If dynamics is true, this projector will be + * instrumented with a probe to collect dynamic + * information during evaluation */ + let dynamics: bool; /* Renders a DOM view for the projector, given the * model, an info packet (see info type for details), * and has two callbacks: ~parent for parent editor * actions(see external_action type above), and ~local * for this projector's local update function. */ - let dynamics: bool; - /* If dynamics is true, this projector will be - * instrumented with a probe to collect dynamic - * information during evaluation */ let view: ( model, @@ -104,6 +100,19 @@ module type Projector = { ~utility: utility ) => Node.t; + /* An optional additional view to be rendered at the + * end of the row which includes the projector */ + let offside_view: + option( + ( + model, + ~info: info, + ~local: action => Ui_effect.t(unit), + ~parent: external_action => Ui_effect.t(unit), + ~utility: utility + ) => + Node.t, + ); /* How much space should be left in the code view for * this projector? This determines how the base code * view is laid out, including how movement around the @@ -150,6 +159,18 @@ module Cook = (C: Projector) : Cooked => { ~parent, ~utility, ); + let offside_view = + Option.map( + (f, m, ~info, ~local, ~parent, ~utility) => + f( + deserialize_m(m), + ~info, + ~local=a => local(serialize_a(a)), + ~parent, + ~utility, + ), + C.offside_view, + ); let placeholder = m => m |> Sexplib.Sexp.of_string |> C.model_of_sexp |> C.placeholder; let update = (m, a) => diff --git a/src/haz3lcore/zipper/projectors/CheckboxProj.re b/src/haz3lcore/zipper/projectors/CheckboxProj.re index 3a0f39ab03..08fcefc19f 100644 --- a/src/haz3lcore/zipper/projectors/CheckboxProj.re +++ b/src/haz3lcore/zipper/projectors/CheckboxProj.re @@ -56,5 +56,6 @@ module M: Projector = { let placeholder = (_, _) => ProjectorShape.inline(2); let update = (model, _) => model; let view = view; + let offside_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/FoldProj.re b/src/haz3lcore/zipper/projectors/FoldProj.re index 5942d6653c..d05f771239 100644 --- a/src/haz3lcore/zipper/projectors/FoldProj.re +++ b/src/haz3lcore/zipper/projectors/FoldProj.re @@ -26,5 +26,6 @@ module M: Projector = { ~attrs=[Attr.on_double_click(_ => parent(Remove))], [text(m.text)], ); + let offside_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/InfoProj.re b/src/haz3lcore/zipper/projectors/InfoProj.re index 9d65060355..844976a006 100644 --- a/src/haz3lcore/zipper/projectors/InfoProj.re +++ b/src/haz3lcore/zipper/projectors/InfoProj.re @@ -93,5 +93,6 @@ module M: Projector = { ), ], ); + let offside_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index c12ddf8acd..cc549faa5a 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -235,12 +235,6 @@ let select_vals = (model: model, vals) => { }; }; -let offside_pos = utility => - Attr.create( - "style", - Printf.sprintf("position: absolute; left: %fpx;", utility.offside_offset), - ); - let nav_back = (di, model, local, left_cond) => List.length(di) > model.max_closures ? [ @@ -271,9 +265,10 @@ let nav_forward = (di, model, local, right_cond) => ] : []; -let offside_view = (info, ~model: model, ~local, ~utility: utility) => { +let offside_view = + (model: model, ~info, ~local, ~parent as _, ~utility: utility) => { Node.div( - ~attrs=[Attr.classes(["live-offside"]), offside_pos(utility)], + ~attrs=[Attr.classes(["live-offside"])], switch (info.dynamics) { | Some(di) => let vals = select_vals(model, di); @@ -321,9 +316,10 @@ let placeholder = (_m, info) => // let icon = div(~attrs=[Attr.classes(["icon"])], [text("🔍")]); let icon = div(~attrs=[Attr.classes(["icon"])], []); -let view = (model: model, ~info, ~local, ~parent as _, ~utility: utility) => { +let view = + (_: model, ~info, ~local as _, ~parent as _, ~utility as _: utility) => { div([ - offside_view(info, ~model, ~local, ~utility), + //offside_view(info, ~model, ~local, ~utility), div( ~attrs=[ Attr.classes( @@ -341,7 +337,7 @@ let view = (model: model, ~info, ~local, ~parent as _, ~utility: utility) => { }; let update = (m: model, a: action) => { - print_endline("update: action:" ++ show_action(a)); + //print_endline("update: action:" ++ show_action(a)); switch (a) { | ChangeLength(id, len) => if (len > (-1)) { @@ -377,5 +373,6 @@ module M: Projector = { let placeholder = placeholder; let update = update; let view = view; + let offside_view = Some(offside_view); let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/SliderFProj.re b/src/haz3lcore/zipper/projectors/SliderFProj.re index 04a4ee3690..006c9d9b33 100644 --- a/src/haz3lcore/zipper/projectors/SliderFProj.re +++ b/src/haz3lcore/zipper/projectors/SliderFProj.re @@ -39,5 +39,6 @@ module M: Projector = { ~attrs=[Attr.on_input((_, v) => parent(SetSyntax(put(v))))], get(info.syntax) |> Printf.sprintf("%.2f"), ); + let offside_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/SliderProj.re b/src/haz3lcore/zipper/projectors/SliderProj.re index f3681fd40f..f89095d2cb 100644 --- a/src/haz3lcore/zipper/projectors/SliderProj.re +++ b/src/haz3lcore/zipper/projectors/SliderProj.re @@ -36,5 +36,6 @@ module M: Projector = { ~attrs=[Attr.on_input((_, v) => parent(SetSyntax(put(v))))], get(info.syntax), ); + let offside_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/TextAreaProj.re b/src/haz3lcore/zipper/projectors/TextAreaProj.re index 55bb0caec1..3006515a20 100644 --- a/src/haz3lcore/zipper/projectors/TextAreaProj.re +++ b/src/haz3lcore/zipper/projectors/TextAreaProj.re @@ -109,6 +109,7 @@ module M: Projector = { }; let update = (model, _) => model; let view = view; + let offside_view = Option.None; let focus = ((id: Id.t, d: option(Direction.t))) => { JsUtil.get_elem_by_id(of_id(id))##focus; switch (d) { diff --git a/src/haz3lweb/app/common/ProjectorView.re b/src/haz3lweb/app/common/ProjectorView.re index e09802201a..06373a3b90 100644 --- a/src/haz3lweb/app/common/ProjectorView.re +++ b/src/haz3lweb/app/common/ProjectorView.re @@ -71,6 +71,7 @@ let view_wrapper = ~indication: option(Direction.t), ~selected: bool, p: Base.projector, + offside_view: option(Node.t), view: Node.t, ) => { let sort = @@ -85,7 +86,8 @@ let view_wrapper = Attr.on_mousedown(focus(info.id)), DecUtil.abs_style(measurement, ~font_metrics), ], - [view, backing_deco(~font_metrics, ~measurement)], + [view, backing_deco(~font_metrics, ~measurement)] + @ Option.to_list(offside_view), ); }; @@ -114,24 +116,17 @@ let offside = - measurement.origin.col, ); +let offside_pos = offside_offset => + Attr.create( + "style", + Printf.sprintf("position: absolute; left: %fpx;", offside_offset), + ); + /* Gather utility functions/values to be passed to the projector. * See ProjectorBase.utility definition for more information */ -let collate_utility = - ( - globals: Globals.t, - measurement: Measured.measurement, - cached_syntax: Editor.CachedSyntax.t, - ) - : ProjectorBase.utility => { +let collate_utility = (globals: Globals.t): ProjectorBase.utility => { { font_metrics: globals.font_metrics, - offside_offset: - offside( - ~offset=4, - globals.font_metrics, - measurement, - cached_syntax.measured, - ), view: (sort, seg) => CodeViewable.view_segment( ~globals, @@ -175,10 +170,28 @@ let setup_view = let dynamics = Dynamics.Map.lookup(id, dynamics); let info = {id, statics, dynamics, syntax}; let+ measurement = Measured.find_pr_opt(p, cached_syntax.measured); - let utility = collate_utility(globals, measurement, cached_syntax); + let utility = collate_utility(globals); let (module P) = to_module(p.kind); let parent = a => inject(Project(handle(id, a))); let local = a => inject(Project(SetModel(id, P.update(p.model, a)))); + let offside_pos = + offside_pos( + offside( + ~offset=4, + globals.font_metrics, + measurement, + cached_syntax.measured, + ), + ); + let offside_view = + Option.map( + v => + div( + ~attrs=[offside_pos], + [v(p.model, ~info, ~local, ~parent, ~utility)], + ), + P.offside_view, + ); view_wrapper( ~inject, ~font_metrics=globals.font_metrics, @@ -187,6 +200,7 @@ let setup_view = ~info, ~selected=List.mem(id, cached_syntax.selection_ids), p, + offside_view, P.view(p.model, ~info, ~local, ~parent, ~utility), ); }; diff --git a/src/haz3lweb/app/inspector/ProjectorPanel.re b/src/haz3lweb/app/inspector/ProjectorPanel.re index 7ffb3d29d7..f22607cf68 100644 --- a/src/haz3lweb/app/inspector/ProjectorPanel.re +++ b/src/haz3lweb/app/inspector/ProjectorPanel.re @@ -101,29 +101,43 @@ let lift = (str, strs) => List.cons(str, List.filter((!=)(str), strs)); * indicated syntax, with the currently applied projection (if any) * lifted to the top of the list */ let applicable_projector_strings = (cursor: Cursor.cursor(Editors.Update.t)) => { - let strs = - applicable_projectors(cursor.info) |> List.map(ProjectorView.name); + let strs = applicable_projectors(cursor.info); switch (kind(cursor.editor)) { | None => strs - | Some(k) => lift(ProjectorView.name(k), strs) + | Some(k) => lift(k, strs) }; }; +let keyboard_shortcut_of = (kind: Base.kind): string => + switch (kind) { + | Fold => "Option-f" + | Probe => "Option-v" + | _ => "" + }; + /* A selection input for contetually applicable projectors */ let select_view = ( ~inject: Action.project => Ui_effect.t(unit), cursor: Cursor.cursor(Editors.Update.t), ) => { - let applicable_projector_strings = + let applicable_projectors = might_project(cursor) ? applicable_projector_strings(cursor) : []; + let applicable_projector_strings = + List.map(ProjectorView.name, applicable_projectors); let value = switch (applicable_projector_strings) { | [] => "" | [hd, ..._] => hd }; + let title = + switch (applicable_projectors) { + | [] => "" + | [hd, ..._] => keyboard_shortcut_of(hd) + }; Node.select( ~attrs=[ + Attr.title(title), Attr.on_change((_, name) => inject(SetIndicated(ProjectorView.of_name(name))) ), diff --git a/src/haz3lweb/www/style/cursor-inspector.css b/src/haz3lweb/www/style/cursor-inspector.css index a97c0c633b..eef8ba8e26 100644 --- a/src/haz3lweb/www/style/cursor-inspector.css +++ b/src/haz3lweb/www/style/cursor-inspector.css @@ -4,6 +4,9 @@ display: flex; align-items: stretch; gap: 0.5em; + /* Below is to permit access to projector panel if ci is too wide */ + overflow: hidden; + min-width: 0; } #cursor-inspector.no-info { @@ -55,7 +58,7 @@ #cursor-inspector .ci-header .gamma:hover, #cursor-inspector .ci-header.error .gamma:hover, #cursor-inspector .ci-header .gamma.visible, -#cursor-inspector .ci-header.error .gamma.visible, +#cursor-inspector .ci-header.error .gamma.visible, #bottom-bar:has(~ .context-inspector:hover) .gamma { background-color: #dfcc99; outline: 0.3px solid var(--BR3); @@ -94,22 +97,22 @@ #cursor-inspector .ci-header.ok .toggle-switch .toggle-knob { background-color: var(--SAND); } -#cursor-inspector .ci-header.ok.Exp .toggle-switch.active { +#cursor-inspector .ci-header.ok.Exp .toggle-switch.active { background-color: var(--BR3); } -#cursor-inspector .ci-header.ok.Pat .toggle-switch.active { +#cursor-inspector .ci-header.ok.Pat .toggle-switch.active { background-color: var(--token-pat); } -#cursor-inspector .ci-header.ok.Typ .toggle-switch.active { +#cursor-inspector .ci-header.ok.Typ .toggle-switch.active { background-color: var(--token-typ); } -#cursor-inspector .ci-header.ok.TPat .toggle-switch.active { +#cursor-inspector .ci-header.ok.TPat .toggle-switch.active { background-color: var(--token-tpat); } -#cursor-inspector .ci-header.ok.Exp .toggle-switch .toggle-knob { +#cursor-inspector .ci-header.ok.Exp .toggle-switch .toggle-knob { color: var(--BR3); } -#cursor-inspector .ci-header.ok.Pat .toggle-switch .toggle-knob{ +#cursor-inspector .ci-header.ok.Pat .toggle-switch .toggle-knob { color: var(--token-pat); } #cursor-inspector .ci-header.ok.Typ .toggle-switch .toggle-knob { @@ -176,7 +179,6 @@ position: relative; } - #page > .context-inspector { position: absolute; z-index: var(--context-inspector-z); @@ -241,4 +243,4 @@ .context-inspector .context-entry .seperator { color: var(--context-inspector-colon); -} \ No newline at end of file +} diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index b47bde6028..21a3bc376c 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -101,8 +101,8 @@ .projector.probe .live-offside { display: flex; flex-direction: row; - position: absolute; - left: 10em; + /* position: absolute; + left: 10em; */ gap: 2px; align-items: center; } From 4b84511cce671192485dc2e97d5cfebeb2c5c3cf Mon Sep 17 00:00:00 2001 From: disconcision Date: Mon, 13 Jan 2025 21:31:54 -0500 Subject: [PATCH 250/281] give projectors access to maketerm through utility --- src/haz3lcore/zipper/ProjectorBase.re | 3 ++ src/haz3lcore/zipper/projectors/ProbeProj.re | 33 +++++++++----------- src/haz3lweb/app/common/ProjectorView.re | 1 + src/haz3lweb/www/style/projectors/probe.css | 2 -- 4 files changed, 18 insertions(+), 21 deletions(-) diff --git a/src/haz3lcore/zipper/ProjectorBase.re b/src/haz3lcore/zipper/ProjectorBase.re index b267ff24e7..886376f10d 100644 --- a/src/haz3lcore/zipper/ProjectorBase.re +++ b/src/haz3lcore/zipper/ProjectorBase.re @@ -42,6 +42,9 @@ type utility = { /* Convert an expression to a segment, included here * because of cyclic dependency issues*/ exp_to_seg: Exp.t => Base.segment, + /* Convert a segment to an expression, included here + * because of cyclic dependency issues*/ + seg_to_exp: Base.segment => Exp.t, }; /* To add a new projector: diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index cc549faa5a..76d8c36df4 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -313,28 +313,23 @@ let syntax_view = (info: info) => info |> syntax_str |> text; let placeholder = (_m, info) => ProjectorShape.inline(3 + String.length(syntax_str(info))); -// let icon = div(~attrs=[Attr.classes(["icon"])], [text("🔍")]); let icon = div(~attrs=[Attr.classes(["icon"])], []); let view = - (_: model, ~info, ~local as _, ~parent as _, ~utility as _: utility) => { - div([ - //offside_view(info, ~model, ~local, ~utility), - div( - ~attrs=[ - Attr.classes( - ["main"] @ (Option.is_some(cur_ap_id(info)) ? ["ap"] : []), - ), - Attr.on_click(_ => { - env_cursor := []; - cur_ap := None; - Effect.Ignore; - }), - ], - [syntax_view(info), icon, num_closures_view(info)], - ), - ]); -}; + (_: model, ~info, ~local as _, ~parent as _, ~utility as _: utility) => + div( + ~attrs=[ + Attr.classes( + ["main"] @ (Option.is_some(cur_ap_id(info)) ? ["ap"] : []), + ), + Attr.on_click(_ => { + env_cursor := []; + cur_ap := None; + Effect.Ignore; + }), + ], + [syntax_view(info), icon, num_closures_view(info)], + ); let update = (m: model, a: action) => { //print_endline("update: action:" ++ show_action(a)); diff --git a/src/haz3lweb/app/common/ProjectorView.re b/src/haz3lweb/app/common/ProjectorView.re index 06373a3b90..848ea9db36 100644 --- a/src/haz3lweb/app/common/ProjectorView.re +++ b/src/haz3lweb/app/common/ProjectorView.re @@ -146,6 +146,7 @@ let collate_utility = (globals: Globals.t): ProjectorBase.utility => { fold_cast_types: false, }, ), + seg_to_exp: seg => MakeTerm.go(seg).term, }; }; diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index 21a3bc376c..6f80b19a25 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -101,8 +101,6 @@ .projector.probe .live-offside { display: flex; flex-direction: row; - /* position: absolute; - left: 10em; */ gap: 2px; align-items: center; } From e843e6bf814bfc14a0608641389e16950124b585 Mon Sep 17 00:00:00 2001 From: disconcision Date: Mon, 13 Jan 2025 23:42:57 -0500 Subject: [PATCH 251/281] indicate the 'outer ap' a closure was created by --- src/haz3lcore/zipper/projectors/ProbeProj.re | 124 +++++++++++++------ src/haz3lweb/www/style/projectors/probe.css | 42 ++++--- src/util/ListUtil.re | 5 +- 3 files changed, 108 insertions(+), 63 deletions(-) diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index 76d8c36df4..3cc7f30207 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -42,27 +42,78 @@ let stack = stack => ) |> String.concat("\n"); -let env_cursor: ref(list(Id.t)) = ref([]); -let last_target: ref(list('a)) = ref([]); -let cur_ap: ref(option(Id.t)) = ref(Option.None); -let cur_ap_depth: ref(option(int)) = ref(Option.None); -let mousedown: ref(option(Js.t(Dom_html.element))) = ref(Option.None); +let cur_ap_id = (info: info) => + switch (info.statics) { + | Some(InfoExp({term: {term: Ap(_), _} as ap, _})) => + Some(Term.Exp.rep_id(ap)) + | Some(InfoExp({term: {term: Wrap({term: Ap(_), _} as ap, _), _}, _})) => + Some(Term.Exp.rep_id(ap)) + | _ => None + }; + +let cur_outer_ap_id = (_info: info, dyn_stack: Probe.stack) => + switch (dyn_stack) { + | [{ap_id, _}, ..._] => Some(ap_id) + | _ => None + }; + +module State = { + let env_cursor: ref(list(Id.t)) = ref([]); + let cur_ap: ref(option(Id.t)) = ref(Option.None); + let outer_ap_id: ref(option(Id.t)) = ref(Option.None); + + let reset = () => { + env_cursor := []; + cur_ap := None; + outer_ap_id := None; + }; + + let capture = (info: info, closure: Dynamics.Probe.Closure.t) => { + env_cursor := Probe.env_stack(closure.stack); + cur_ap := cur_ap_id(info); + outer_ap_id := cur_outer_ap_id(info, closure.dyn_stack); + }; +}; let comparor = (a: Dynamics.Probe.Closure.t, b: Dynamics.Probe.Closure.t) => { compare( - ListUtil.common_suffix_length(env_cursor^, Probe.env_stack(b.stack)), - ListUtil.common_suffix_length(env_cursor^, Probe.env_stack(a.stack)), + ListUtil.common_suffix_length( + State.env_cursor^, + Probe.env_stack(b.stack), + ), + ListUtil.common_suffix_length( + State.env_cursor^, + Probe.env_stack(a.stack), + ), ); }; let show_indicator = stack => { let local = Probe.env_stack(stack); - env_cursor^ == [] + State.env_cursor^ == [] && local == [] - || env_cursor^ != [] - && ListUtil.one_is_suffix_of_other(env_cursor^, local); + || State.env_cursor^ != [] + && ListUtil.is_suffix_of(local, State.env_cursor^); }; +let depth_in_cur_ap_stack = (dyn_stack): option(int) => + List.find_index( + ({ap_id, _}: Probe.frame) => Some(ap_id) == State.cur_ap^, + dyn_stack, + ); + +let is_in_cur_ap_stack = (dyn_stack): bool => + switch (depth_in_cur_ap_stack(dyn_stack)) { + | Some(_) => true + | None => false + }; + +let on_outer_ap = (info: info): bool => + switch (cur_ap_id(info), State.outer_ap_id^) { + | (Some(ap_id), Some(outer_ap_id)) => ap_id == outer_ap_id + | _ => false + }; + let seg_view = (utility, available, seg) => seg |> DHExp.strip_casts @@ -81,20 +132,22 @@ let get_goal = (utility: utility, e: Js.t(Dom_html.mouseEvent)) => e |> Js.Unsafe.coerce, ); -let cur_ap_id = (info: info) => - switch (info.statics) { - | Some(InfoExp({term: {term: Ap(_), _} as ap, _})) => - Some(Term.Exp.rep_id(ap)) - | Some(InfoExp({term: {term: Wrap({term: Ap(_), _} as ap, _), _}, _})) => - Some(Term.Exp.rep_id(ap)) - | _ => None - }; +let mousedown: ref(option(Js.t(Dom_html.element))) = ref(Option.None); -let depth_in_stack = (dyn_stack): option(int) => - List.find_index( - ({ap_id, _}: Probe.frame) => Some(ap_id) == cur_ap^, - dyn_stack, - ); +let dynamic_cursor_cls = (closure: Dynamics.Probe.Closure.t) => + switch (is_in_cur_ap_stack(closure.dyn_stack)) { + | true + when + ListUtil.is_suffix_of( + State.env_cursor^, + Probe.env_stack(closure.stack), + ) => [ + "cursor-ap-lex", + ] + | true => ["cursor-ap"] + | _ when show_indicator(closure.stack) => ["cursor-lex"] + | false => ["cursor-none"] + }; let value_view = (info: info, model, utility, local, closure: Dynamics.Probe.Closure.t) => { @@ -102,10 +155,7 @@ let value_view = let target = e##.target |> Js.Opt.get(_, _ => failwith("no target")); JsUtil.setPointerCapture(target, e##.pointerId) |> ignore; mousedown := Some(target); - env_cursor := Probe.env_stack(closure.stack); - last_target := [target]; - cur_ap := cur_ap_id(info); - cur_ap_depth := Some(List.length(closure.dyn_stack)); + State.capture(info, closure); Effect.Ignore; }; @@ -139,21 +189,16 @@ let value_view = ), Attr.classes( ["val-resize"] + @ dynamic_cursor_cls(closure) + @ (on_outer_ap(info) ? ["outer-ap"] : []) @ ( - switch (depth_in_stack(closure.dyn_stack)) { - | Some(0) => ["dyn-cursor"] - | Some(_) => ["dyn-cursor", "light"] + switch (depth_in_cur_ap_stack(closure.dyn_stack)) { + | Some(0) | None => [] + | Some(_) => ["light"] } ) - @ (Option.is_some(cur_ap_id(info)) ? ["ap"] : []) - @ ( - switch (cur_ap_depth^) { - | Some(0) => ["top-ap"] - | _ => [] - } - ) - @ (show_indicator(closure.stack) ? ["cursor"] : []), + @ (Option.is_some(cur_ap_id(info)) ? ["ap"] : []), ), Attr.on_double_click(_ => local(ToggleShowAllVals)), Attr.on_pointerdown(val_pointerdown), @@ -323,8 +368,7 @@ let view = ["main"] @ (Option.is_some(cur_ap_id(info)) ? ["ap"] : []), ), Attr.on_click(_ => { - env_cursor := []; - cur_ap := None; + State.reset(); Effect.Ignore; }), ], diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index 6f80b19a25..5bb65e1809 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -128,51 +128,57 @@ background-color: var(--pat-base); } /* TOKEN OPACITY */ -.projector.probe .val-resize.cursor .code-text { +.projector.probe .val-resize.cursor-lex .code-text { opacity: 100%; } -.projector.probe .val-resize.dyn-cursor.cursor .code-text, -.projector.probe .val-resize.dyn-cursor.top-ap .code-text { +.projector.probe .val-resize.cursor-ap-lex .code-text { opacity: 100%; outline: 1px solid var(--TYP); } -.projector.probe .val-resize.dyn-cursor:not(.cursor):not(.top-ap) .code-text { +.projector.probe .val-resize.cursor-lex.outer-ap .code-text { + outline: 1px solid var(--TYP); + background-color: var(--TYP); +} +/* .projector.probe .val-resize.cursor-ap .code-text { opacity: 100%; - /* outline: 1px solid var(--TYP); */ outline: 1px dotted var(--TYP); -} +} */ .projector.probe .val-resize .code-text { opacity: 51%; } -.projector.probe .val-resize.dyn-cursor.light .code-text { +.projector.probe .val-resize.cursor-ap.light .code-text, +.projector.probe .val-resize.cursor-ap-lex.light .code-text { opacity: 45%; } .projector.probe.indicated .val-resize .code-text { opacity: 60%; } -.projector.probe.indicated .val-resize.cursor .code-text { +.projector.probe.indicated .val-resize.cursor-lex .code-text { opacity: 100%; background: none; outline: 2.8px solid var(--exp-indicated); } -.projector.probe.indicated .val-resize.cursor.ap .code-text { +.projector.probe.indicated .val-resize.cursor-lex.ap .code-text { outline-color: var(--TYP); } +.projector.probe.indicated.Pat .val-resize.cursor-lex .code-text { + outline-color: var(--pat-indicated); +} /* TOKENS */ -.projector.probe - .val-resize.dyn-cursor:not(.cursor):not(.top-ap) - .code-text - .token { +.projector.probe .val-resize.cursor-ap .code-text .token { filter: invert(1) brightness(10); /* color: var(--TYP); */ } -.projector.probe .val-resize:not(.dyn-cursor):not(.cursor) .code-text .token { +.projector.probe .val-resize.cursor-none .code-text .token { filter: invert(1) brightness(10); } -.projector.probe .val-resize.dyn-cursor.cursor .code-text .token, -.projector.probe .val-resize.dyn-cursor.top-ap .code-text .token { +.projector.probe .val-resize.cursor-ap-lex .code-text .token { color: var(--TYP); } +.projector.probe .val-resize.cursor-lex.outer-ap .code-text .token { + /* color: var(--TYP); */ + color: white; +} .projector.probe .val-resize .code-text:hover { filter: brightness(1.05) saturate(1.05); @@ -208,10 +214,6 @@ color: white; } -.projector.probe.indicated.Pat .val-resize.cursor .code-text { - outline-color: var(--pat-indicated); -} - .projector.probe.indicated .closure:hover .live-env { display: block; } diff --git a/src/util/ListUtil.re b/src/util/ListUtil.re index bc40065201..4c47e92db0 100644 --- a/src/util/ListUtil.re +++ b/src/util/ListUtil.re @@ -608,9 +608,8 @@ let max_common_suffix = (a: list('a), b: list('a)): list('a) => { let common_suffix_length = (s1, s2) => List.length(max_common_suffix(s1, s2)); -let one_is_suffix_of_other = (s1, s2) => - common_suffix_length(s1, s2) == List.length(s1) - || common_suffix_length(s1, s2) == List.length(s2); +let is_suffix_of = (s1, s2) => + common_suffix_length(s1, s2) == List.length(s1); /* list truncated after at most n elementsnts */ let truncate = (n: int, xs: list('a)): list('a) => { From 72268ef7ad120cf16c1fa919e2995279bb4f8c43 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 14 Jan 2025 11:58:18 -0500 Subject: [PATCH 252/281] Add test case for deferred application in segmentization --- test/Test_ExpToSegment.re | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/test/Test_ExpToSegment.re b/test/Test_ExpToSegment.re index a9844790da..59038d5212 100644 --- a/test/Test_ExpToSegment.re +++ b/test/Test_ExpToSegment.re @@ -71,5 +71,31 @@ let tests = ( ); }, ), + test_case( + "Deferred application", + `Quick, + () => { + let segment = + segmentize( + DeferredAp( + Var("string_sub") |> Exp.fresh, + [ + String("hello") |> Exp.fresh, + Int(1) |> Exp.fresh, + Deferral(InAp) |> Exp.fresh, + ], + ) + |> Exp.fresh, + ); + let serialized = Printer.of_segment(~holes=Some("?"), segment); + + check( + string, + "deferral in application", + serialized, + {|string_sub("hello", 1, _)|}, + ); + }, + ), ], ); From f4bad31c0c8eade0bcd8ef264c695633760dfc0d Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 14 Jan 2025 11:59:20 -0500 Subject: [PATCH 253/281] Update Deferral in ExpToSegment to use underscore --- src/haz3lcore/pretty/ExpToSegment.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index 9fa4b15bde..084a0d9d1b 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -178,7 +178,7 @@ let rec exp_to_pretty = (~settings: Settings.t, exp: Exp.t): pretty => { // @ [mk_form("typeasc", id, [])] // @ (t |> fold_if(settings.fold_cast_types)); | ListLit([]) => text_to_pretty(exp |> Exp.rep_id, Sort.Exp, "[]") - | Deferral(_) => text_to_pretty(exp |> Exp.rep_id, Sort.Exp, "deferral") + | Deferral(_) => text_to_pretty(exp |> Exp.rep_id, Sort.Exp, "_") | ListLit([x, ...xs]) => // TODO: Add optional newlines let* x = go(x) From 0e8493b596e7baa827b8dc87bb628a5193ec6cc5 Mon Sep 17 00:00:00 2001 From: Matt Keenan Date: Tue, 14 Jan 2025 11:59:21 -0500 Subject: [PATCH 254/281] Fix #1445 --- src/haz3lcore/pretty/ExpToSegment.re | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index c2f57d0229..d815615b07 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -943,10 +943,22 @@ let rec parenthesize = (exp: Exp.t): Exp.t => { | UnOp(Int(Minus), e) => UnOp(Int(Minus), parenthesize(e) |> paren_at(Precedence.neg)) |> rewrap | BinOp(op, e1, e2) => - BinOp( - op, - parenthesize(e1) |> paren_assoc_at(Precedence.of_bin_op(op)), - parenthesize(e2) |> paren_at(Precedence.of_bin_op(op)), + ( + switch (Precedence.of_bin_op(op) |> Precedence.associativity) { + | Some(Left) + | None => + BinOp( + op, + parenthesize(e1) |> paren_assoc_at(Precedence.of_bin_op(op)), + parenthesize(e2) |> paren_at(Precedence.of_bin_op(op)), + ) + | Some(Right) => + BinOp( + op, + parenthesize(e1) |> paren_at(Precedence.of_bin_op(op)), + parenthesize(e2) |> paren_assoc_at(Precedence.of_bin_op(op)), + ) + } ) |> rewrap | Match(e, rs) => From 03ff4a267928c21905b20d23e3fae35fc103d44a Mon Sep 17 00:00:00 2001 From: Matt Keenan Date: Tue, 14 Jan 2025 11:59:21 -0500 Subject: [PATCH 255/281] Fix #1445 --- src/haz3lcore/pretty/ExpToSegment.re | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index 9fa4b15bde..14f96565b6 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -961,10 +961,22 @@ let rec parenthesize = (exp: Exp.t): Exp.t => { | UnOp(Int(Minus), e) => UnOp(Int(Minus), parenthesize(e) |> paren_at(Precedence.neg)) |> rewrap | BinOp(op, e1, e2) => - BinOp( - op, - parenthesize(e1) |> paren_assoc_at(Precedence.of_bin_op(op)), - parenthesize(e2) |> paren_at(Precedence.of_bin_op(op)), + ( + switch (Precedence.of_bin_op(op) |> Precedence.associativity) { + | Some(Left) + | None => + BinOp( + op, + parenthesize(e1) |> paren_assoc_at(Precedence.of_bin_op(op)), + parenthesize(e2) |> paren_at(Precedence.of_bin_op(op)), + ) + | Some(Right) => + BinOp( + op, + parenthesize(e1) |> paren_at(Precedence.of_bin_op(op)), + parenthesize(e2) |> paren_assoc_at(Precedence.of_bin_op(op)), + ) + } ) |> rewrap | Match(e, rs) => From 5a80d2e08c52d5dfce1322bded4b16c2192073aa Mon Sep 17 00:00:00 2001 From: Matt Keenan Date: Tue, 14 Jan 2025 12:23:03 -0500 Subject: [PATCH 256/281] Fix precedence of list concatenation --- src/haz3lcore/lang/Form.re | 2 +- src/haz3lmenhir/Parser.mly | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/haz3lcore/lang/Form.re b/src/haz3lcore/lang/Form.re index fe936143be..512962e778 100644 --- a/src/haz3lcore/lang/Form.re +++ b/src/haz3lcore/lang/Form.re @@ -275,7 +275,7 @@ let forms: list((string, t)) = [ ("logical_and", mk_infix("&&", Exp, P.and_)), ("logical_or_legacy", mk_infix("\\/", Exp, P.or_)), ("logical_or", mk_infix("||", Exp, P.or_)), - ("list_concat", mk_infix("@", Exp, P.plus)), + ("list_concat", mk_infix("@", Exp, P.concat)), ("cons_exp", mk_infix("::", Exp, P.cons)), ("cons_pat", mk_infix("::", Pat, P.cons)), ("typeann", mk(ss, [":"], mk_bin'(P.cast, Pat, Pat, [], Typ))), diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 83df6af129..d59da3065e 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -124,10 +124,10 @@ open AST %left GREATER_THAN LESS_THAN DOUBLE_EQUAL NOT_EQUAL LESS_THAN_EQUAL GREATER_THAN_EQUAL NOT_EQUAL_FLOAT LESS_THAN_FLOAT LESS_THAN_EQUAL_FLOAT GREATER_THAN_FLOAT GREATER_THAN_EQUAL_FLOAT DOUBLE_EQUAL_FLOAT STRING_EQUAL -%right STRING_CONCAT +%right STRING_CONCAT AT_SYMBOL %right CONS -%left AT_SYMBOL PLUS MINUS PLUS_FLOAT MINUS_FLOAT +%left PLUS MINUS PLUS_FLOAT MINUS_FLOAT %left DIVIDE TIMES TIMES_FLOAT DIVIDE_FLOAT L_NOT %right POWER POWER_FLOAT From 87818d042f40bab1e9173260e3d2a1cd67344c10 Mon Sep 17 00:00:00 2001 From: Matt Keenan Date: Tue, 14 Jan 2025 12:42:10 -0500 Subject: [PATCH 257/281] Parenthesize types in TyAlias --- src/haz3lcore/pretty/ExpToSegment.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index 14f96565b6..266e16f2b3 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -875,7 +875,7 @@ let rec parenthesize = (exp: Exp.t): Exp.t => { | TyAlias(tp, t, e) => TyAlias( tp, - t, // TODO: Types + t |> paren_typ_at(Precedence.min), parenthesize(e) |> paren_assoc_at(Precedence.let_), ) |> rewrap From 31d688d3ac359f06f238ece437229b904565b821 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 14 Jan 2025 13:23:16 -0500 Subject: [PATCH 258/281] Add support for filters in ExpToSegment - Also adjusted menhir precedence for filters to maintain compatibility --- src/haz3lcore/pretty/ExpToSegment.re | 86 +++++++++++++------ src/haz3lmenhir/Parser.mly | 3 +- src/haz3lweb/app/inspector/CursorInspector.re | 6 ++ src/haz3lweb/view/ContextInspector.re | 1 + src/haz3lweb/view/Kind.re | 1 + test/Test_ExpToSegment.re | 43 +++++++++- 6 files changed, 108 insertions(+), 32 deletions(-) diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index 084a0d9d1b..8ffb23d598 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -9,6 +9,7 @@ module Settings = { fold_fn_bodies: bool, hide_fixpoints: bool, fold_cast_types: bool, + show_filters: bool, }; let of_core = (~inline, settings: CoreSettings.t) => { @@ -17,6 +18,7 @@ module Settings = { fold_fn_bodies: !settings.evaluation.show_fn_bodies, hide_fixpoints: !settings.evaluation.show_fixpoints, fold_cast_types: !settings.evaluation.show_casts, + show_filters: false, }; }; @@ -152,8 +154,14 @@ let rec exp_to_pretty = (~settings: Settings.t, exp: Exp.t): pretty => { exp_to_pretty(~settings={...settings, inline}); switch (exp |> Exp.term_of) { // Assume these have been removed by the parenthesizer - | DynamicErrorHole(_) - | Filter(_) => failwith("printing these not implemented yet") + | DynamicErrorHole(_) => failwith("printing these not implemented yet") + | Filter(Residue(_), e) => go(e) + | Filter(Filter({pat, act}), e) => + let label = FilterAction.string_of_t(act); + let id = exp |> Exp.rep_id; + let* p = go(pat); + let+ e = go(e); + [mk_form("filter_" ++ label, id, [p])] @ e; // Forms which should be removed by substitute_closures | Closure(_) => failwith("closure not removed before printing") // Other cases @@ -812,7 +820,10 @@ let paren_typ_assoc_at = external_precedence_typ(typ) > internal_precedence ? Typ.fresh(Parens(typ)) : typ; -let rec parenthesize = (exp: Exp.t): Exp.t => { +let rec parenthesize = (~preserve_filters: bool, exp: Exp.t): Exp.t => { + let parenthesize = parenthesize(~preserve_filters); + let parenthesize_pat = parenthesize_pat(~preserve_filters); + let parenthesize_typ = parenthesize_typ(~preserve_filters); let (term, rewrap) = Exp.unwrap(exp); switch (term) { // Indivisible forms dont' change @@ -831,9 +842,11 @@ let rec parenthesize = (exp: Exp.t): Exp.t => { // Forms that currently need to stripped before outputting | Closure(_, x) | DynamicErrorHole(x, _) - | Tuple([x]) - | Filter(_, x) => x |> parenthesize - + | Tuple([x]) => parenthesize(x) + | Filter(Filter({pat, act}), x) => + Filter(Filter({pat: parenthesize(pat), act}), parenthesize(x)) + |> rewrap + | Filter(Residue(_), x) => x |> parenthesize // TODO // Other forms | Constructor(c, t) => Constructor(c, paren_typ_at(Precedence.cast, t)) |> rewrap @@ -979,10 +992,13 @@ let rec parenthesize = (exp: Exp.t): Exp.t => { ), ) |> rewrap - | MultiHole(xs) => MultiHole(List.map(parenthesize_any, xs)) |> rewrap + | MultiHole(xs) => + MultiHole(List.map(parenthesize_any(~preserve_filters), xs)) |> rewrap }; } -and parenthesize_pat = (pat: Pat.t): Pat.t => { +and parenthesize_pat = (~preserve_filters: bool, pat: Pat.t): Pat.t => { + let parenthesize_pat = parenthesize_pat(~preserve_filters); + let parenthesize_typ = parenthesize_typ(~preserve_filters); let (term, rewrap) = Pat.unwrap(pat); switch (term) { // Indivisible forms dont' change @@ -1025,7 +1041,8 @@ and parenthesize_pat = (pat: Pat.t): Pat.t => { parenthesize_pat(p2) |> paren_pat_at(Precedence.min), ) |> rewrap - | MultiHole(xs) => MultiHole(List.map(parenthesize_any, xs)) |> rewrap + | MultiHole(xs) => + MultiHole(List.map(parenthesize_any(~preserve_filters), xs)) |> rewrap | Cast(p, t1, t2) => Cast( parenthesize_pat(p) |> paren_pat_assoc_at(Precedence.cast), @@ -1036,7 +1053,8 @@ and parenthesize_pat = (pat: Pat.t): Pat.t => { }; } -and parenthesize_typ = (typ: Typ.t): Typ.t => { +and parenthesize_typ = (~preserve_filters: bool, typ: Typ.t): Typ.t => { + let parenthesize_typ = parenthesize_typ(~preserve_filters); let (term, rewrap) = Typ.unwrap(typ); switch (term) { // Indivisible forms dont' change @@ -1098,11 +1116,14 @@ and parenthesize_typ = (typ: Typ.t): Typ.t => { ) |> rewrap | Unknown(Hole(MultiHole(xs))) => - Unknown(Hole(MultiHole(List.map(parenthesize_any, xs)))) |> rewrap + Unknown( + Hole(MultiHole(List.map(parenthesize_any(~preserve_filters), xs))), + ) + |> rewrap }; } -and parenthesize_tpat = (tpat: TPat.t): TPat.t => { +and parenthesize_tpat = (~preserve_filters: bool, tpat: TPat.t): TPat.t => { let (term, rewrap: TPat.term => TPat.t) = IdTagged.unwrap(tpat); switch (term) { // Indivisible forms dont' change @@ -1111,11 +1132,12 @@ and parenthesize_tpat = (tpat: TPat.t): TPat.t => { | EmptyHole => tpat // Other forms - | MultiHole(xs) => MultiHole(List.map(parenthesize_any, xs)) |> rewrap + | MultiHole(xs) => + MultiHole(List.map(parenthesize_any(~preserve_filters), xs)) |> rewrap }; } -and parenthesize_rul = (rul: Rul.t): Rul.t => { +and parenthesize_rul = (~preserve_filters: bool, rul: Rul.t): Rul.t => { let (term, rewrap: Rul.term => Rul.t) = IdTagged.unwrap(rul); switch (term) { // Indivisible forms dont' change @@ -1124,33 +1146,45 @@ and parenthesize_rul = (rul: Rul.t): Rul.t => { // Other forms | Rules(e, ps) => Rules( - parenthesize(e), - List.map(((p, e)) => (parenthesize_pat(p), parenthesize(e)), ps), + parenthesize(~preserve_filters, e), + List.map( + ((p, e)) => + ( + parenthesize_pat(~preserve_filters, p), + parenthesize(~preserve_filters, e), + ), + ps, + ), ) |> rewrap - | Hole(xs) => Hole(List.map(parenthesize_any, xs)) |> rewrap + | Hole(xs) => + Hole(List.map(parenthesize_any(~preserve_filters), xs)) |> rewrap }; } -and parenthesize_any = (any: Any.t): Any.t => +and parenthesize_any = (~preserve_filters: bool, any: Any.t): Any.t => switch (any) { - | Exp(e) => Exp(parenthesize(e)) - | Pat(p) => Pat(parenthesize_pat(p)) - | Typ(t) => Typ(parenthesize_typ(t)) - | TPat(tp) => TPat(parenthesize_tpat(tp)) - | Rul(r) => Rul(parenthesize_rul(r)) + | Exp(e) => Exp(parenthesize(~preserve_filters, e)) + | Pat(p) => Pat(parenthesize_pat(~preserve_filters, p)) + | Typ(t) => Typ(parenthesize_typ(~preserve_filters, t)) + | TPat(tp) => TPat(parenthesize_tpat(~preserve_filters, tp)) + | Rul(r) => Rul(parenthesize_rul(~preserve_filters, r)) | Any(_) => any | Nul(_) => any }; -let exp_to_segment = (~settings, exp: Exp.t): Segment.t => { - let exp = exp |> Exp.substitute_closures(Builtins.env_init) |> parenthesize; +let exp_to_segment = (~settings: Settings.t, exp: Exp.t): Segment.t => { + let exp = + exp + |> Exp.substitute_closures(Builtins.env_init) + |> parenthesize(~preserve_filters=settings.show_filters); let p = exp_to_pretty(~settings, exp); p |> PrettySegment.select; }; let typ_to_segment = (~settings, typ: Typ.t): Segment.t => { let typ = parenthesize_typ(typ); - let p = typ_to_pretty(~settings, typ); + let p = + typ_to_pretty(~settings, typ(~preserve_filters=settings.show_filters)); p |> PrettySegment.select; }; diff --git a/src/haz3lmenhir/Parser.mly b/src/haz3lmenhir/Parser.mly index 83df6af129..ba2a92972a 100644 --- a/src/haz3lmenhir/Parser.mly +++ b/src/haz3lmenhir/Parser.mly @@ -136,7 +136,6 @@ open AST %left OPEN_CURLY -%left IN %nonassoc TYP_AP_SYMBOL @@ -325,7 +324,7 @@ exp: | FIX; p = funPat; DASH_ARROW; e = exp { FixF(p, e) } | TYP_FUN; t = tpat; DASH_ARROW; e = exp {TypFun(t, e)} | QUESTION { EmptyHole } - | a = filterAction; cond = exp; IN; body = exp { Filter(a, cond, body)} + | a = filterAction; cond = exp; IN; body = exp { Filter(a, cond, body)} %prec LET_EXP | TEST; e = exp; END { Test(e) } | e1 = exp; AT_SYMBOL; e2 = exp { ListConcat(e1, e2) } | e1 = exp; CONS; e2 = exp { Cons(e1, e2) } diff --git a/src/haz3lweb/app/inspector/CursorInspector.re b/src/haz3lweb/app/inspector/CursorInspector.re index febb507ada..b33aec0586 100644 --- a/src/haz3lweb/app/inspector/CursorInspector.re +++ b/src/haz3lweb/app/inspector/CursorInspector.re @@ -85,6 +85,7 @@ let common_err_view = (~globals, cls: Cls.t, err: Info.error_common) => { fold_fn_bodies: false, hide_fixpoints: false, fold_cast_types: false, + show_filters: false, }, ~info_map=Id.Map.empty, ) @@ -131,6 +132,7 @@ let common_ok_view = (~globals, cls: Cls.t, ok: Info.ok_pat) => { fold_fn_bodies: false, hide_fixpoints: false, fold_cast_types: false, + show_filters: false, }, ); switch (cls, ok) { @@ -182,6 +184,7 @@ let typ_ok_view = (~globals, cls: Cls.t, ok: Info.ok_typ) => { fold_fn_bodies: false, hide_fixpoints: false, fold_cast_types: false, + show_filters: false, }, ~info_map=Id.Map.empty, ); @@ -215,6 +218,7 @@ let typ_err_view = (~globals, ok: Info.error_typ) => { fold_fn_bodies: false, hide_fixpoints: false, fold_cast_types: false, + show_filters: false, }, ~info_map=Id.Map.empty, ); @@ -247,6 +251,7 @@ let rec exp_view = (~globals, cls: Cls.t, status: Info.status_exp) => { fold_fn_bodies: false, hide_fixpoints: false, fold_cast_types: false, + show_filters: false, }, ~info_map=Id.Map.empty, ); @@ -319,6 +324,7 @@ let tpat_view = (~globals, _: Cls.t, status: Info.status_tpat) => { fold_fn_bodies: false, hide_fixpoints: false, fold_cast_types: false, + show_filters: false, }, ~info_map=Id.Map.empty, ); diff --git a/src/haz3lweb/view/ContextInspector.re b/src/haz3lweb/view/ContextInspector.re index 3e48eb2109..257afd793a 100644 --- a/src/haz3lweb/view/ContextInspector.re +++ b/src/haz3lweb/view/ContextInspector.re @@ -18,6 +18,7 @@ let context_entry_view = (~globals, entry: Haz3lcore.Ctx.entry): Node.t => { fold_fn_bodies: false, hide_fixpoints: false, fold_cast_types: false, + show_filters: false, }, ); let div_name = div(~attrs=[clss(["name"])]); diff --git a/src/haz3lweb/view/Kind.re b/src/haz3lweb/view/Kind.re index 0eee9db324..345d4bfe01 100644 --- a/src/haz3lweb/view/Kind.re +++ b/src/haz3lweb/view/Kind.re @@ -16,6 +16,7 @@ let view = (~globals, kind: Haz3lcore.Ctx.kind): Node.t => fold_fn_bodies: false, hide_fixpoints: false, fold_cast_types: false, + show_filters: false, }, ~info_map=Haz3lcore.Id.Map.empty, ty, diff --git a/test/Test_ExpToSegment.re b/test/Test_ExpToSegment.re index 59038d5212..50c1938e76 100644 --- a/test/Test_ExpToSegment.re +++ b/test/Test_ExpToSegment.re @@ -3,7 +3,14 @@ open Haz3lcore; let segmentize = ExpToSegment.exp_to_segment( - ~settings=ExpToSegment.Settings.of_core(~inline=true, CoreSettings.off), + ~settings={ + inline: true, + fold_case_clauses: false, + fold_fn_bodies: true, + hide_fixpoints: true, + fold_cast_types: true, + show_filters: true, + }, _, ); @@ -33,8 +40,8 @@ let tests = ( check( string, "ascribed sum type constructor in pattern", - serialized, "let []: (+ Jg) = ? in ?", + serialized, ); }, ), @@ -66,8 +73,8 @@ let tests = ( check( string, "Match statement", - serialized, "case x | A => 1| B => 2 end", + serialized, ); }, ), @@ -92,10 +99,38 @@ let tests = ( check( string, "deferral in application", - serialized, {|string_sub("hello", 1, _)|}, + serialized, ); }, ), + test_case( + "Test", + `Quick, + () => { + let segment = + segmentize(Test(Bool(true) |> Exp.fresh) |> Exp.fresh); + let serialized = Printer.of_segment(~holes=Some("?"), segment); + + check(string, "Test of true", {|test true end|}, serialized); + }, + ), + test_case( + "Filter", + `Quick, + () => { + let segment = + segmentize( + Filter( + Filter({pat: Int(1) |> Exp.fresh, act: (Step, One)}), + Int(2) |> Exp.fresh, + ) + |> Exp.fresh, + ); + let serialized = Printer.of_segment(~holes=Some("?"), segment); + + check(string, "Pause", serialized, {|pause 1 in 2|}); + }, + ), ], ); From 639d0b569918f29ed253dc913af1c53bba1df428 Mon Sep 17 00:00:00 2001 From: disconcision Date: Tue, 14 Jan 2025 13:45:24 -0500 Subject: [PATCH 259/281] projector probe state refactor --- src/haz3lcore/zipper/projectors/ProbeProj.re | 58 ++++++++++++-------- src/haz3lweb/www/style/projectors/probe.css | 8 ++- 2 files changed, 41 insertions(+), 25 deletions(-) diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index 3cc7f30207..d156582d98 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -58,31 +58,43 @@ let cur_outer_ap_id = (_info: info, dyn_stack: Probe.stack) => }; module State = { - let env_cursor: ref(list(Id.t)) = ref([]); - let cur_ap: ref(option(Id.t)) = ref(Option.None); - let outer_ap_id: ref(option(Id.t)) = ref(Option.None); + type t = { + mutable env_cursor: list(Id.t), + mutable dyn_env_cursor: list(Id.t), + mutable cur_ap: option(Id.t), + mutable outer_ap_id: option(Id.t), + }; + + let s: t = { + env_cursor: [], + dyn_env_cursor: [], + cur_ap: None, + outer_ap_id: None, + }; let reset = () => { - env_cursor := []; - cur_ap := None; - outer_ap_id := None; + s.env_cursor = []; + s.dyn_env_cursor = []; + s.cur_ap = None; + s.outer_ap_id = None; }; let capture = (info: info, closure: Dynamics.Probe.Closure.t) => { - env_cursor := Probe.env_stack(closure.stack); - cur_ap := cur_ap_id(info); - outer_ap_id := cur_outer_ap_id(info, closure.dyn_stack); + s.env_cursor = Probe.env_stack(closure.stack); + s.dyn_env_cursor = Probe.env_stack(closure.dyn_stack); + s.cur_ap = cur_ap_id(info); + s.outer_ap_id = cur_outer_ap_id(info, closure.dyn_stack); }; }; let comparor = (a: Dynamics.Probe.Closure.t, b: Dynamics.Probe.Closure.t) => { compare( ListUtil.common_suffix_length( - State.env_cursor^, + State.s.env_cursor, Probe.env_stack(b.stack), ), ListUtil.common_suffix_length( - State.env_cursor^, + State.s.env_cursor, Probe.env_stack(a.stack), ), ); @@ -90,15 +102,15 @@ let comparor = (a: Dynamics.Probe.Closure.t, b: Dynamics.Probe.Closure.t) => { let show_indicator = stack => { let local = Probe.env_stack(stack); - State.env_cursor^ == [] + State.s.env_cursor == [] && local == [] - || State.env_cursor^ != [] - && ListUtil.is_suffix_of(local, State.env_cursor^); + || State.s.env_cursor != [] + && ListUtil.is_suffix_of(local, State.s.env_cursor); }; let depth_in_cur_ap_stack = (dyn_stack): option(int) => List.find_index( - ({ap_id, _}: Probe.frame) => Some(ap_id) == State.cur_ap^, + ({ap_id, _}: Probe.frame) => Some(ap_id) == State.s.cur_ap, dyn_stack, ); @@ -108,12 +120,6 @@ let is_in_cur_ap_stack = (dyn_stack): bool => | None => false }; -let on_outer_ap = (info: info): bool => - switch (cur_ap_id(info), State.outer_ap_id^) { - | (Some(ap_id), Some(outer_ap_id)) => ap_id == outer_ap_id - | _ => false - }; - let seg_view = (utility, available, seg) => seg |> DHExp.strip_casts @@ -134,12 +140,18 @@ let get_goal = (utility: utility, e: Js.t(Dom_html.mouseEvent)) => let mousedown: ref(option(Js.t(Dom_html.element))) = ref(Option.None); +let on_outer_ap = (info: info, _closure): bool => + switch (cur_ap_id(info), State.s.outer_ap_id) { + | (Some(ap_id), Some(outer_ap_id)) => ap_id == outer_ap_id + | _ => false + }; + let dynamic_cursor_cls = (closure: Dynamics.Probe.Closure.t) => switch (is_in_cur_ap_stack(closure.dyn_stack)) { | true when ListUtil.is_suffix_of( - State.env_cursor^, + State.s.env_cursor, Probe.env_stack(closure.stack), ) => [ "cursor-ap-lex", @@ -190,7 +202,7 @@ let value_view = Attr.classes( ["val-resize"] @ dynamic_cursor_cls(closure) - @ (on_outer_ap(info) ? ["outer-ap"] : []) + @ (on_outer_ap(info, closure) ? ["outer-ap"] : []) @ ( switch (depth_in_cur_ap_stack(closure.dyn_stack)) { | Some(0) diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index 5bb65e1809..9bf169a278 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -153,10 +153,14 @@ .projector.probe.indicated .val-resize .code-text { opacity: 60%; } -.projector.probe.indicated .val-resize.cursor-lex .code-text { +.projector.probe.indicated .closure.cursor .val-resize .code-text { opacity: 100%; background: none; - outline: 2.8px solid var(--exp-indicated); + outline-width: 2.8px; + outline-style: solid; +} +.projector.probe.indicated .val-resize.cursor-lex .code-text { + outline-color: var(--exp-indicated); } .projector.probe.indicated .val-resize.cursor-lex.ap .code-text { outline-color: var(--TYP); From 8a6003313935223e70f19e561ccef82c767999a3 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 14 Jan 2025 14:16:40 -0500 Subject: [PATCH 260/281] Added tests --- test/Test_ExpToSegment.re | 60 +++++++++++++++++++++++++++++++++++++++ test/Test_Menhir.re | 9 +++--- test/haz3ltest.re | 2 +- 3 files changed, 66 insertions(+), 5 deletions(-) diff --git a/test/Test_ExpToSegment.re b/test/Test_ExpToSegment.re index 50c1938e76..9b0c2ac8fe 100644 --- a/test/Test_ExpToSegment.re +++ b/test/Test_ExpToSegment.re @@ -132,5 +132,65 @@ let tests = ( check(string, "Pause", serialized, {|pause 1 in 2|}); }, ), + test_case( + "Right associativity", + `Quick, + () => { + check( + string, + "No parens", + Printer.of_segment( + ~holes=Some("?"), + segmentize( + BinOp( + Int(Power), + Int(2) |> Exp.fresh, + BinOp(Int(Power), Int(3) |> Exp.fresh, Int(4) |> Exp.fresh) + |> Exp.fresh, + ) + |> Exp.fresh, + ), + ), + {|2 ** 3 ** 4|}, + ); + check( + string, + "Parens", + Printer.of_segment( + ~holes=Some("?"), + segmentize( + BinOp( + Int(Power), + BinOp(Int(Power), Int(2) |> Exp.fresh, Int(3) |> Exp.fresh) + |> Exp.fresh, + Int(4) |> Exp.fresh, + ) + |> Exp.fresh, + ), + ), + {|(2 ** 3) ** 4|}, + ); + check( + string, + "Arrow types", + Printer.of_segment( + ~holes=Some("?"), + segmentize( + TyAlias( + Var("x") |> TPat.fresh, + Arrow( + Arrow(Int |> Typ.fresh, Bool |> Typ.fresh) |> Typ.fresh, + Var("x") |> Typ.fresh, + ) + |> Typ.fresh, + Int(1) |> Exp.fresh, + ) + |> Exp.fresh, + ), + ), + {|type x = (Int -> Bool) -> x in 1|}, + ); + }, + ), ], ); diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 837ad14bfb..0d789c8d9d 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -146,8 +146,8 @@ let qcheck_menhir_maketerm_equivalent_test = let qcheck_menhir_serialized_equivalent_test = QCheck.Test.make( ~name="Menhir through ExpToSegment and back", - ~count=1000, - QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(4)), + ~count=10000, + QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(7)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); @@ -160,9 +160,10 @@ let qcheck_menhir_serialized_equivalent_test = ), core_exp, ); - let serialized = Printer.of_segment(~holes=Some("?"), segment); + print_endline(serialized); let menhir_parsed = Haz3lmenhir.Interface.parse_program(serialized); + print_endline("Parsed: " ++ AST.show_exp(menhir_parsed)); AST.equal_exp(menhir_parsed, exp); }, ); @@ -821,6 +822,6 @@ let ex5 = list_of_mylist(x) in ), QCheck_alcotest.to_alcotest(qcheck_menhir_maketerm_equivalent_test), // Disabled due to bugs in ExpToSegment - // QCheck_alcotest.to_alcotest(qcheck_menhir_serialized_equivalent_test), + QCheck_alcotest.to_alcotest(qcheck_menhir_serialized_equivalent_test), ], ); diff --git a/test/haz3ltest.re b/test/haz3ltest.re index a1050103e3..fc8c52e543 100644 --- a/test/haz3ltest.re +++ b/test/haz3ltest.re @@ -5,13 +5,13 @@ let (suite, _) = ~and_exit=false, "HazelTests", [ + Test_ExpToSegment.tests, Test_Menhir.tests, Test_StringUtil.tests, Test_Statics.tests, Test_Evaluator.tests, Test_ListUtil.tests, Test_MakeTerm.tests, - Test_ExpToSegment.tests, ] @ Test_Elaboration.tests, ); From 9d4e25eabbc0e495dc2dd793f782b5f393b838b3 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 14 Jan 2025 14:38:33 -0500 Subject: [PATCH 261/281] Update settings in tests --- test/Test_ExpToSegment.re | 6 +++--- test/Test_Menhir.re | 13 ++++++++----- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/test/Test_ExpToSegment.re b/test/Test_ExpToSegment.re index 9b0c2ac8fe..65bbe18ace 100644 --- a/test/Test_ExpToSegment.re +++ b/test/Test_ExpToSegment.re @@ -6,9 +6,9 @@ let segmentize = ~settings={ inline: true, fold_case_clauses: false, - fold_fn_bodies: true, - hide_fixpoints: true, - fold_cast_types: true, + fold_fn_bodies: false, + hide_fixpoints: false, + fold_cast_types: false, show_filters: true, }, _, diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 0d789c8d9d..882729e50a 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -153,11 +153,14 @@ let qcheck_menhir_serialized_equivalent_test = let segment = ExpToSegment.exp_to_segment( - ~settings= - ExpToSegment.Settings.of_core( - ~inline=true, // TODO What does inline do? - CoreSettings.off, - ), + ~settings={ + inline: true, + fold_case_clauses: false, + fold_fn_bodies: false, + hide_fixpoints: false, + fold_cast_types: false, + show_filters: true, + }, core_exp, ); let serialized = Printer.of_segment(~holes=Some("?"), segment); From 0c00552bdf95a129622de1e379e5595bc4216e0e Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 14 Jan 2025 14:51:32 -0500 Subject: [PATCH 262/281] Make and/or right associative --- src/haz3lcore/lang/Precedence.re | 4 ++-- src/haz3lcore/pretty/ExpToSegment.re | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/haz3lcore/lang/Precedence.re b/src/haz3lcore/lang/Precedence.re index 3a5b54ec5b..1c76d241fa 100644 --- a/src/haz3lcore/lang/Precedence.re +++ b/src/haz3lcore/lang/Precedence.re @@ -70,10 +70,10 @@ let concat = 29 |> right_associative; let eqs = 30 |> left_associative; // _____ == x // _____ && true -let and_ = 31; +let and_ = 31 |> right_associative; // true && _____ // _____ || false -let or_ = 32; +let or_ = 32 |> right_associative; // false || _____ let if_ = 34; let fun_ = 35; diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index ba34c0d726..1dcadd7b46 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -888,7 +888,7 @@ let rec parenthesize = (~preserve_filters: bool, exp: Exp.t): Exp.t => { | TyAlias(tp, t, e) => TyAlias( tp, - t |> paren_typ_at(Precedence.min), + parenthesize_typ(t) |> paren_typ_at(Precedence.min), parenthesize(e) |> paren_assoc_at(Precedence.let_), ) |> rewrap From 7bebf386da523e45d653f63358026e58c1e884a4 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 14 Jan 2025 15:13:36 -0500 Subject: [PATCH 263/281] show_filters instead of preserve_filters --- src/haz3lcore/pretty/ExpToSegment.re | 55 ++++++++++++++-------------- 1 file changed, 27 insertions(+), 28 deletions(-) diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index 1dcadd7b46..857a22c03b 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -820,10 +820,10 @@ let paren_typ_assoc_at = external_precedence_typ(typ) > internal_precedence ? Typ.fresh(Parens(typ)) : typ; -let rec parenthesize = (~preserve_filters: bool, exp: Exp.t): Exp.t => { - let parenthesize = parenthesize(~preserve_filters); - let parenthesize_pat = parenthesize_pat(~preserve_filters); - let parenthesize_typ = parenthesize_typ(~preserve_filters); +let rec parenthesize = (~show_filters: bool, exp: Exp.t): Exp.t => { + let parenthesize = parenthesize(~show_filters); + let parenthesize_pat = parenthesize_pat(~show_filters); + let parenthesize_typ = parenthesize_typ(~show_filters); let (term, rewrap) = Exp.unwrap(exp); switch (term) { // Indivisible forms dont' change @@ -1005,12 +1005,12 @@ let rec parenthesize = (~preserve_filters: bool, exp: Exp.t): Exp.t => { ) |> rewrap | MultiHole(xs) => - MultiHole(List.map(parenthesize_any(~preserve_filters), xs)) |> rewrap + MultiHole(List.map(parenthesize_any(~show_filters), xs)) |> rewrap }; } -and parenthesize_pat = (~preserve_filters: bool, pat: Pat.t): Pat.t => { - let parenthesize_pat = parenthesize_pat(~preserve_filters); - let parenthesize_typ = parenthesize_typ(~preserve_filters); +and parenthesize_pat = (~show_filters: bool, pat: Pat.t): Pat.t => { + let parenthesize_pat = parenthesize_pat(~show_filters); + let parenthesize_typ = parenthesize_typ(~show_filters); let (term, rewrap) = Pat.unwrap(pat); switch (term) { // Indivisible forms dont' change @@ -1054,7 +1054,7 @@ and parenthesize_pat = (~preserve_filters: bool, pat: Pat.t): Pat.t => { ) |> rewrap | MultiHole(xs) => - MultiHole(List.map(parenthesize_any(~preserve_filters), xs)) |> rewrap + MultiHole(List.map(parenthesize_any(~show_filters), xs)) |> rewrap | Cast(p, t1, t2) => Cast( parenthesize_pat(p) |> paren_pat_assoc_at(Precedence.cast), @@ -1065,8 +1065,8 @@ and parenthesize_pat = (~preserve_filters: bool, pat: Pat.t): Pat.t => { }; } -and parenthesize_typ = (~preserve_filters: bool, typ: Typ.t): Typ.t => { - let parenthesize_typ = parenthesize_typ(~preserve_filters); +and parenthesize_typ = (~show_filters: bool, typ: Typ.t): Typ.t => { + let parenthesize_typ = parenthesize_typ(~show_filters); let (term, rewrap) = Typ.unwrap(typ); switch (term) { // Indivisible forms dont' change @@ -1129,13 +1129,13 @@ and parenthesize_typ = (~preserve_filters: bool, typ: Typ.t): Typ.t => { |> rewrap | Unknown(Hole(MultiHole(xs))) => Unknown( - Hole(MultiHole(List.map(parenthesize_any(~preserve_filters), xs))), + Hole(MultiHole(List.map(parenthesize_any(~show_filters), xs))), ) |> rewrap }; } -and parenthesize_tpat = (~preserve_filters: bool, tpat: TPat.t): TPat.t => { +and parenthesize_tpat = (~show_filters: bool, tpat: TPat.t): TPat.t => { let (term, rewrap: TPat.term => TPat.t) = IdTagged.unwrap(tpat); switch (term) { // Indivisible forms dont' change @@ -1145,11 +1145,11 @@ and parenthesize_tpat = (~preserve_filters: bool, tpat: TPat.t): TPat.t => { // Other forms | MultiHole(xs) => - MultiHole(List.map(parenthesize_any(~preserve_filters), xs)) |> rewrap + MultiHole(List.map(parenthesize_any(~show_filters), xs)) |> rewrap }; } -and parenthesize_rul = (~preserve_filters: bool, rul: Rul.t): Rul.t => { +and parenthesize_rul = (~show_filters: bool, rul: Rul.t): Rul.t => { let (term, rewrap: Rul.term => Rul.t) = IdTagged.unwrap(rul); switch (term) { // Indivisible forms dont' change @@ -1158,29 +1158,29 @@ and parenthesize_rul = (~preserve_filters: bool, rul: Rul.t): Rul.t => { // Other forms | Rules(e, ps) => Rules( - parenthesize(~preserve_filters, e), + parenthesize(~show_filters, e), List.map( ((p, e)) => ( - parenthesize_pat(~preserve_filters, p), - parenthesize(~preserve_filters, e), + parenthesize_pat(~show_filters, p), + parenthesize(~show_filters, e), ), ps, ), ) |> rewrap | Hole(xs) => - Hole(List.map(parenthesize_any(~preserve_filters), xs)) |> rewrap + Hole(List.map(parenthesize_any(~show_filters), xs)) |> rewrap }; } -and parenthesize_any = (~preserve_filters: bool, any: Any.t): Any.t => +and parenthesize_any = (~show_filters: bool, any: Any.t): Any.t => switch (any) { - | Exp(e) => Exp(parenthesize(~preserve_filters, e)) - | Pat(p) => Pat(parenthesize_pat(~preserve_filters, p)) - | Typ(t) => Typ(parenthesize_typ(~preserve_filters, t)) - | TPat(tp) => TPat(parenthesize_tpat(~preserve_filters, tp)) - | Rul(r) => Rul(parenthesize_rul(~preserve_filters, r)) + | Exp(e) => Exp(parenthesize(~show_filters, e)) + | Pat(p) => Pat(parenthesize_pat(~show_filters, p)) + | Typ(t) => Typ(parenthesize_typ(~show_filters, t)) + | TPat(tp) => TPat(parenthesize_tpat(~show_filters, tp)) + | Rul(r) => Rul(parenthesize_rul(~show_filters, r)) | Any(_) => any | Nul(_) => any }; @@ -1189,14 +1189,13 @@ let exp_to_segment = (~settings: Settings.t, exp: Exp.t): Segment.t => { let exp = exp |> Exp.substitute_closures(Builtins.env_init) - |> parenthesize(~preserve_filters=settings.show_filters); + |> parenthesize(~show_filters=settings.show_filters); let p = exp_to_pretty(~settings, exp); p |> PrettySegment.select; }; let typ_to_segment = (~settings, typ: Typ.t): Segment.t => { let typ = parenthesize_typ(typ); - let p = - typ_to_pretty(~settings, typ(~preserve_filters=settings.show_filters)); + let p = typ_to_pretty(~settings, typ(~show_filters=settings.show_filters)); p |> PrettySegment.select; }; From c9a6ce5114c9a7a755e3fc81a2141e133d6ecad8 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 14 Jan 2025 15:13:44 -0500 Subject: [PATCH 264/281] Remove print statements --- test/Test_Menhir.re | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 882729e50a..2bb20ce22a 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -164,9 +164,7 @@ let qcheck_menhir_serialized_equivalent_test = core_exp, ); let serialized = Printer.of_segment(~holes=Some("?"), segment); - print_endline(serialized); let menhir_parsed = Haz3lmenhir.Interface.parse_program(serialized); - print_endline("Parsed: " ++ AST.show_exp(menhir_parsed)); AST.equal_exp(menhir_parsed, exp); }, ); From 94c9d6618b6fb2a0586ac89bddc2261088373d28 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 14 Jan 2025 15:16:12 -0500 Subject: [PATCH 265/281] Remove residue filter from exp_to_pretty --- src/haz3lcore/pretty/ExpToSegment.re | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/haz3lcore/pretty/ExpToSegment.re b/src/haz3lcore/pretty/ExpToSegment.re index 857a22c03b..a0b185c67e 100644 --- a/src/haz3lcore/pretty/ExpToSegment.re +++ b/src/haz3lcore/pretty/ExpToSegment.re @@ -154,8 +154,8 @@ let rec exp_to_pretty = (~settings: Settings.t, exp: Exp.t): pretty => { exp_to_pretty(~settings={...settings, inline}); switch (exp |> Exp.term_of) { // Assume these have been removed by the parenthesizer - | DynamicErrorHole(_) => failwith("printing these not implemented yet") - | Filter(Residue(_), e) => go(e) + | DynamicErrorHole(_) + | Filter(Residue(_), _) => failwith("printing these not implemented yet") | Filter(Filter({pat, act}), e) => let label = FilterAction.string_of_t(act); let id = exp |> Exp.rep_id; @@ -846,7 +846,7 @@ let rec parenthesize = (~show_filters: bool, exp: Exp.t): Exp.t => { | Filter(Filter({pat, act}), x) => Filter(Filter({pat: parenthesize(pat), act}), parenthesize(x)) |> rewrap - | Filter(Residue(_), x) => x |> parenthesize // TODO + | Filter(Residue(_), x) => x |> parenthesize // Other forms | Constructor(c, t) => Constructor(c, paren_typ_at(Precedence.cast, t)) |> rewrap From c821c7f657d92d9d99d0ba563273979466985688 Mon Sep 17 00:00:00 2001 From: Alexander Bandukwala <7h3kk1d@gmail.com> Date: Tue, 14 Jan 2025 15:16:20 -0500 Subject: [PATCH 266/281] Revert test count change --- test/Test_Menhir.re | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Test_Menhir.re b/test/Test_Menhir.re index 2bb20ce22a..94ce4edffa 100644 --- a/test/Test_Menhir.re +++ b/test/Test_Menhir.re @@ -146,7 +146,7 @@ let qcheck_menhir_maketerm_equivalent_test = let qcheck_menhir_serialized_equivalent_test = QCheck.Test.make( ~name="Menhir through ExpToSegment and back", - ~count=10000, + ~count=1000, QCheck.make(~print=AST.show_exp, AST.gen_exp_sized(7)), exp => { let core_exp = Conversion.Exp.of_menhir_ast(exp); From 28fb563b4114bcc4d1d0b7ee0a02119740300cb5 Mon Sep 17 00:00:00 2001 From: disconcision Date: Tue, 14 Jan 2025 16:08:44 -0500 Subject: [PATCH 267/281] fixed ap tracking bug. added probe doc slide --- src/haz3lcore/statics/TermBase.re | 7 +- src/haz3lcore/zipper/projectors/ProbeProj.re | 107 +- src/haz3lweb/Init.ml | 1315 ++++++++++++++++++ src/haz3lweb/www/style/projectors/probe.css | 7 +- 4 files changed, 1373 insertions(+), 63 deletions(-) diff --git a/src/haz3lcore/statics/TermBase.re b/src/haz3lcore/statics/TermBase.re index 9f4195520b..8754b7e888 100644 --- a/src/haz3lcore/statics/TermBase.re +++ b/src/haz3lcore/statics/TermBase.re @@ -985,13 +985,14 @@ and ClosureEnvironment: { let without_keys = keys => update_env(Environment.without_keys(keys)); - let update_stack = (ap_id: option(Id.t), env) => { + let update_stack = (dyn_env, ap_id: option(Id.t), env) => { let (stack, dyn_stack) = switch (ap_id) { | None => (stack_of(env), dyn_stack_of(env)) | Some(ap_id) => let frame = Probe.mk_frame(~env_id=id_of(env), ~ap_id); - ([frame, ...stack_of(env)], [frame, ...dyn_stack_of(env)]); + let dyn_frame = Probe.mk_frame(~env_id=id_of(dyn_env), ~ap_id); + ([frame, ...stack_of(env)], [dyn_frame, ...dyn_stack_of(env)]); }; {...env, stack, dyn_stack}; }; @@ -1016,7 +1017,7 @@ and ClosureEnvironment: { dyn_stack: dyn_stack_of(dyn_env.env == Environment.empty ? to_extend : dyn_env) //TODO(andrew): cleanup } - |> update_stack(frame); + |> update_stack(dyn_env, frame); } and StepperFilterKind: { [@deriving (show({with_path: false}), sexp, yojson)] diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index d156582d98..063b5625ef 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -31,16 +31,27 @@ let model_of_sexp = (sexp): model => let display_length = (model: model, id: Id.t): int => Id.Map.find_opt(id, model.display_lengths) |> Option.value(~default=12); -let stack = stack => - stack - |> List.rev - |> List.map(({env_id, ap_id}: Probe.frame) => - "" - ++ String.sub(Id.to_string(env_id), 0, 2) - ++ " : " - ++ String.sub(Id.to_string(ap_id), 0, 2) - ) - |> String.concat("\n"); +module Debug = { + let of_id = (id: Id.t) => String.sub(Id.to_string(id), 0, 3); + + let stack = stack => + stack + |> List.rev + |> List.map(({env_id, ap_id}: Probe.frame) => + "" ++ of_id(env_id) ++ " : " ++ of_id(ap_id) + ) + |> String.concat("\n"); + + let str = (closure: Dynamics.Probe.Closure.t) => + "closure_id: " + ++ of_id(closure.closure_id) + ++ "\nenv_id: " + ++ of_id(closure.env_id) + ++ "\ndyn_stack:\n" + ++ stack(closure.dyn_stack) + ++ "\nstack:\n" + ++ stack(closure.stack); +}; let cur_ap_id = (info: info) => switch (info.statics) { @@ -53,14 +64,14 @@ let cur_ap_id = (info: info) => let cur_outer_ap_id = (_info: info, dyn_stack: Probe.stack) => switch (dyn_stack) { - | [{ap_id, _}, ..._] => Some(ap_id) + | [frame, ..._] => Some(frame.ap_id) | _ => None }; module State = { type t = { mutable env_cursor: list(Id.t), - mutable dyn_env_cursor: list(Id.t), + mutable dyn_env_cursor: list(Probe.frame), mutable cur_ap: option(Id.t), mutable outer_ap_id: option(Id.t), }; @@ -81,7 +92,7 @@ module State = { let capture = (info: info, closure: Dynamics.Probe.Closure.t) => { s.env_cursor = Probe.env_stack(closure.stack); - s.dyn_env_cursor = Probe.env_stack(closure.dyn_stack); + s.dyn_env_cursor = closure.dyn_stack; s.cur_ap = cur_ap_id(info); s.outer_ap_id = cur_outer_ap_id(info, closure.dyn_stack); }; @@ -100,26 +111,12 @@ let comparor = (a: Dynamics.Probe.Closure.t, b: Dynamics.Probe.Closure.t) => { ); }; -let show_indicator = stack => { - let local = Probe.env_stack(stack); - State.s.env_cursor == [] - && local == [] - || State.s.env_cursor != [] - && ListUtil.is_suffix_of(local, State.s.env_cursor); -}; - let depth_in_cur_ap_stack = (dyn_stack): option(int) => List.find_index( ({ap_id, _}: Probe.frame) => Some(ap_id) == State.s.cur_ap, dyn_stack, ); -let is_in_cur_ap_stack = (dyn_stack): bool => - switch (depth_in_cur_ap_stack(dyn_stack)) { - | Some(_) => true - | None => false - }; - let seg_view = (utility, available, seg) => seg |> DHExp.strip_casts @@ -140,25 +137,36 @@ let get_goal = (utility: utility, e: Js.t(Dom_html.mouseEvent)) => let mousedown: ref(option(Js.t(Dom_html.element))) = ref(Option.None); -let on_outer_ap = (info: info, _closure): bool => +let on_outer_ap = (info: info, closure: Dynamics.Probe.Closure.t): bool => switch (cur_ap_id(info), State.s.outer_ap_id) { - | (Some(ap_id), Some(outer_ap_id)) => ap_id == outer_ap_id + | (Some(ap_id), Some(outer_ap_id)) => + ap_id == outer_ap_id + && closure.env_id + == Option.value( + ~default={ap_id: Id.invalid, env_id: Id.invalid}, + ListUtil.hd_opt(State.s.dyn_env_cursor), + ). + env_id | _ => false }; -let dynamic_cursor_cls = (closure: Dynamics.Probe.Closure.t) => - switch (is_in_cur_ap_stack(closure.dyn_stack)) { - | true - when - ListUtil.is_suffix_of( - State.s.env_cursor, - Probe.env_stack(closure.stack), - ) => [ - "cursor-ap-lex", - ] - | true => ["cursor-ap"] +let show_indicator = stack => { + let local = Probe.env_stack(stack); + State.s.env_cursor == [] + && local == [] + || State.s.env_cursor != [] + && ListUtil.is_suffix_of(local, State.s.env_cursor); +}; + +let dynamic_cursor_cls = (info: info, closure: Dynamics.Probe.Closure.t) => + switch (depth_in_cur_ap_stack(closure.dyn_stack)) { + | _ when on_outer_ap(info, closure) => ["cursor-outer-ap"] + | Some(depth) + when ListUtil.is_suffix_of(State.s.dyn_env_cursor, closure.dyn_stack) => + ["cursor-ap-lex"] @ (depth == 0 ? [] : ["light"]) + | Some(depth) => ["cursor-ap"] @ (depth == 0 ? [] : ["light"]) | _ when show_indicator(closure.stack) => ["cursor-lex"] - | false => ["cursor-none"] + | None => ["cursor-none"] }; let value_view = @@ -193,23 +201,10 @@ let value_view = div( ~attrs=[ - Attr.title( - "dyn_stack:\n" - ++ stack(closure.dyn_stack) - ++ "\nstack:\n" - ++ stack(closure.stack), - ), + Attr.title(Debug.str(closure)), Attr.classes( ["val-resize"] - @ dynamic_cursor_cls(closure) - @ (on_outer_ap(info, closure) ? ["outer-ap"] : []) - @ ( - switch (depth_in_cur_ap_stack(closure.dyn_stack)) { - | Some(0) - | None => [] - | Some(_) => ["light"] - } - ) + @ dynamic_cursor_cls(info, closure) @ (Option.is_some(cur_ap_id(info)) ? ["ap"] : []), ), Attr.on_double_click(_ => local(ToggleShowAllVals)), diff --git a/src/haz3lweb/Init.ml b/src/haz3lweb/Init.ml index e8ee282e9d..866d778207 100644 --- a/src/haz3lweb/Init.ml +++ b/src/haz3lweb/Init.ml @@ -73,6 +73,1321 @@ let startup : PersistentData.t = documentation = ( 2, [ + ( "Probes", + { + zipper = + "((selection((focus Left)(content())(mode \ + Normal)))(backpack())(relatives((siblings(((Secondary((id \ + 2e4f396d-e2a8-4525-b002-7528f8ecf384)(content(Comment\"# \ + PROBE PROJECTORS #\"))))(Secondary((id \ + 8210bd57-34f5-4158-ab9b-10fabe1df80f)(content(Whitespace\"\\n\"))))(Secondary((id \ + 2f48cdfc-e0e5-45ed-a455-34d63b4b1399)(content(Whitespace\"\\n\"))))(Secondary((id \ + 1a171974-2aa0-4b9d-9806-83a849ad3845)(content(Comment\"# You \ + can use the bottom-right projector panel \ + #\"))))(Secondary((id \ + 52056d3d-8b89-4ec7-a8c6-843266b2f64b)(content(Whitespace\"\\n\"))))(Secondary((id \ + 3a01b224-cd29-4480-b316-2cd539c42fea)(content(Comment\"# or \ + alt/option-v (for value) to display live \ + #\"))))(Secondary((id \ + fa40e230-71dc-46f5-8746-f063ad5327b8)(content(Whitespace\"\\n\"))))(Secondary((id \ + 7969ef21-db02-4b6f-b49e-0ae8d97d242f)(content(Comment\"# \ + values for an expression at the end of the \ + #\"))))(Secondary((id \ + 2e489ec0-ff78-4d00-a139-a7a833ed0b81)(content(Whitespace\"\\n\"))))(Secondary((id \ + cdbf03bb-f995-47dc-bb2f-0e6250633fac)(content(Comment\"# \ + line. You can select any such value to see \ + #\"))))(Secondary((id \ + 7eb272cf-da0a-4193-a819-b998d9274d4d)(content(Whitespace\"\\n\"))))(Secondary((id \ + 27298240-100e-45e5-8444-45e4b0b8312d)(content(Comment\"# any \ + environment variables reference in the \ + #\"))))(Secondary((id \ + 27e1f5f5-24fd-4fd1-91e4-69254cac160a)(content(Whitespace\"\\n\"))))(Secondary((id \ + b298f390-af63-4b4c-8afd-8b1a4f7c07eb)(content(Comment\"# \ + probed expression. If the probed expression \ + #\"))))(Secondary((id \ + afbdbd3a-1168-4931-802e-ec61e328e497)(content(Whitespace\"\\n\"))))(Secondary((id \ + 84a18224-b099-4c5a-8823-48cc8ce34c3e)(content(Comment\"# is \ + inside a function, the corresponding ap \ + #\"))))(Secondary((id \ + b678ca9c-e22c-421c-bab5-709a52e99fb4)(content(Whitespace\"\\n\"))))(Secondary((id \ + 6956379a-5db1-456d-aca5-5380be9c27a1)(content(Comment\"# (if \ + also probed) will be filled in purple. \ + #\"))))(Secondary((id \ + 530b3a8e-48f0-4554-b6c1-c95d01cec00e)(content(Whitespace\"\\n\"))))(Secondary((id \ + e4135573-5dd6-4859-8b12-0e964657e404)(content(Comment\"# If \ + the probed expression is an ap, values in \ + #\"))))(Secondary((id \ + 9e630698-940e-45b8-b9da-d98a2ff33b8e)(content(Whitespace\"\\n\"))))(Secondary((id \ + 20f63e20-270f-4df3-8977-3cc6996158ed)(content(Comment\"# the \ + relevant function definition closure, if \ + #\"))))(Secondary((id \ + b82ce1da-ab03-4be3-ab8a-af5dc191411f)(content(Whitespace\"\\n\")))))((Secondary((id \ + b885bff9-5c5b-457a-a96b-acb19ec3f2a7)(content(Comment\"# \ + projected, will be outlined in purple. \ + #\"))))(Secondary((id \ + fe0c955d-8296-475e-8ef4-82bdc988d2ab)(content(Whitespace\"\\n\"))))(Secondary((id \ + 4346c13e-3c97-47b8-895f-1847a9d118fd)(content(Whitespace\"\\n\"))))(Secondary((id \ + deadf426-81c0-4a06-91ca-197171ee3560)(content(Comment\"# \ + top-level unconditional evaluation #\"))))(Secondary((id \ + 76885278-d622-4dcf-8e4c-79c44a75a0ef)(content(Whitespace\"\\n\"))))(Tile((id \ + 3000d752-d923-409e-8e67-8e010d9c9563)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 647dd5f0-1cc3-4462-967d-4548c7f2ea58)(content(Whitespace\" \ + \"))))(Tile((id \ + 367d4582-534e-4ff7-b673-0b1feb804250)(label(a))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + f8e8d3af-8167-4f18-a675-1f1ce4f61477)(content(Whitespace\" \ + \")))))((Secondary((id \ + dcc1a4fb-847b-4a58-8c45-14ff9315089a)(content(Whitespace\" \ + \"))))(Projector((id \ + 80f5d605-8d87-4871-9e87-f7eeb16d54f3)(kind \ + Probe)(syntax(Tile((id \ + 80f5d605-8d87-4871-9e87-f7eeb16d54f3)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + a7fc353f-b559-4c06-acde-74a635fc1a2c)(label(10))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 623e5159-438d-4643-97bc-4ec7e3834c6c)(content(Whitespace\" \ + \"))))(Tile((id \ + 7d1772ba-c6ab-4985-bbf6-9e4ad50e056b)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + fa60fa26-d258-4936-a8cf-27b492327806)(content(Whitespace\" \ + \"))))(Tile((id \ + 1ef47cd6-30e9-4f35-892a-d27fa4f03092)(label(10))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children())))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 8b1fc809-5b94-4340-b403-f642f7ee12c1)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 8f886a2e-412c-431d-9995-fdab6b02b6ca)(content(Whitespace\"\\n\"))))(Tile((id \ + f9853e31-5aa7-44dd-a82e-af03a8ee5b70)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + b9f34a21-57ea-4edd-9182-d65a1379602c)(content(Whitespace\" \ + \"))))(Tile((id \ + 2b80a8b0-6825-4dbf-b7c7-a7a789b0dc74)(label(b))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 0e936f30-84e4-4d24-b1d8-95d5ff287339)(content(Whitespace\" \ + \")))))((Secondary((id \ + fa9336f6-5980-471f-9f58-38e0f9461563)(content(Whitespace\" \ + \"))))(Projector((id \ + 516a758a-28fe-4a23-a128-fb19a410e820)(kind \ + Probe)(syntax(Tile((id \ + 516a758a-28fe-4a23-a128-fb19a410e820)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + a5c46d4b-e294-40c7-97b5-234a97b1cefc)(label(3))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 0fe5e719-ddb8-4f56-8701-ad4c7575a29e)(content(Whitespace\" \ + \"))))(Tile((id \ + 50b01a1f-cd1b-4d2b-a27e-99fa45d87fe3)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 57872b2c-1bf1-4a7f-babe-2e8788ea4efd)(content(Whitespace\" \ + \"))))(Tile((id \ + 5e1f59ef-ed4d-430b-af7a-ace19e85c189)(label(a))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children())))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + a6eebd77-67a0-43d5-bd3b-49cfc50fbbe1)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 0e6bf9c6-5ce8-44c8-94c3-78096f46b6ec)(content(Whitespace\"\\n\"))))(Secondary((id \ + d046139b-ab4f-43e6-90d0-5bdfe3fc8091)(content(Whitespace\"\\n\"))))(Secondary((id \ + 4f7b03f0-00d1-4425-af0b-6827cecbe29b)(content(Comment\"# \ + functions calling functions #\"))))(Secondary((id \ + 2c5deea0-6860-4ae6-8baa-62791e7a2e89)(content(Whitespace\"\\n\"))))(Tile((id \ + a137c9ef-2d61-4ee9-bb17-d9dda9b2a847)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 1acce041-c1d4-4f4b-b18f-62977e8355fb)(content(Whitespace\" \ + \"))))(Tile((id \ + 3bac31bd-00dd-471c-9a51-bf901ebe36b5)(label(fifth))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + a9835df3-b589-47a8-8444-e59b3aa93f90)(content(Whitespace\" \ + \")))))((Secondary((id \ + ce3bf749-cf23-4fd7-ac92-0afac717100a)(content(Whitespace\" \ + \"))))(Tile((id \ + ef90a214-bb3f-46e7-ac4f-8189a8b0c912)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 4798d1b8-a19d-4827-aeb7-021c229b5692)(content(Whitespace\" \ + \"))))(Projector((id \ + c97e794e-a61c-444d-a64c-1392b495128e)(kind \ + Probe)(syntax(Tile((id \ + c97e794e-a61c-444d-a64c-1392b495128e)(label(x))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + ec63e8ad-0fdd-45bd-8e49-0005240ef297)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + e42f841a-9953-4a78-8433-754794af8049)(content(Whitespace\"\\n\"))))(Projector((id \ + cc0f99f4-f669-4e09-ab49-c8c61137ef8a)(kind \ + Probe)(syntax(Tile((id \ + cc0f99f4-f669-4e09-ab49-c8c61137ef8a)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + cc5ea4b9-c3fa-4305-b837-edb87668f9fe)(label(7))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + c31e4832-1dde-469e-9a0a-33f1006115e7)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Tile((id \ + 3dcae31b-3062-40f7-a8db-5e1fde407235)(label(x))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children())))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 2070e7f5-1a9b-4ed3-8b42-a9e548ff82a0)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 9177e4f8-11bd-4171-9fb8-5eeaedeab3e5)(content(Whitespace\"\\n\"))))(Tile((id \ + ec5304e8-dd1a-4bcc-ad61-fb1fe0ee6ad0)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + bdb859a4-36c0-4841-937f-80223fa98c24)(content(Whitespace\" \ + \"))))(Tile((id \ + 800a1e29-08f0-47df-a1dc-dced3ad9d526)(label(fourth))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 1e0d0659-d19c-4dab-ad19-ab01fce29b59)(content(Whitespace\" \ + \")))))((Secondary((id \ + 8f5efc45-a2ee-442d-a27a-9aff78c17c44)(content(Whitespace\" \ + \"))))(Tile((id \ + cb83a2ea-3b39-4f7e-806c-c9e1b58d54ab)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 99a0006d-d489-415d-b217-3237cbeb0ea3)(content(Whitespace\" \ + \"))))(Projector((id \ + b9ee5f14-1489-446d-9170-864b5ba41490)(kind \ + Probe)(syntax(Tile((id \ + b9ee5f14-1489-446d-9170-864b5ba41490)(label(x))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 1fe23d69-172b-408a-a433-da8557e80151)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 14a44874-e543-44f0-b64a-2cf342521e91)(content(Whitespace\" \ + \"))))(Secondary((id \ + 1c57c185-c919-4119-81eb-8d4e9329d5b0)(content(Whitespace\"\\n\"))))(Projector((id \ + a1409f64-ad04-43d6-b70f-81950fcb8192)(kind \ + Probe)(syntax(Tile((id \ + a1409f64-ad04-43d6-b70f-81950fcb8192)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + f54e03db-1c6b-477c-bd87-db346253f867)(label(fifth))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 2352a91d-2891-455f-a665-cd04ad2beba7)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + a8f0b746-d00d-4b15-bf23-d6f7dce50904)(label(x))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + fcb490c3-c1b0-48b7-a56b-da0ec0b2c0a9)(content(Whitespace\" \ + \"))))(Tile((id \ + 3e4f9c0b-6e0c-4999-9ad0-61ca6398ab50)(label(-))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 4a923ca0-5ff4-48f0-bd4f-064fef34a58d)(content(Whitespace\" \ + \"))))(Tile((id \ + c6860869-f0e6-43eb-a301-30c4f455fbdd)(label(4))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + acba5cba-989d-4ede-9bca-37ce99541468)(content(Whitespace\" \ + \"))))(Tile((id \ + 0b2c1381-b8ab-4f0b-9b80-8c77227082ad)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 64a4c16c-6ac1-4d95-ad0e-21858f196f23)(content(Whitespace\" \ + \"))))(Tile((id \ + 540ad80c-634c-49c3-b409-1941592ae887)(label(1))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 46521b0c-8a69-4b06-a2b8-667e9bcc7a90)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 3442b621-9409-4458-b880-fd24ada82816)(content(Whitespace\"\\n\"))))(Tile((id \ + d35bfabb-d398-4b18-a150-f351d931159e)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 102fe5a8-c680-4a8d-8709-811d71142cff)(content(Whitespace\" \ + \"))))(Tile((id \ + f130e49d-aba3-43bd-8346-fec8c01c6fc5)(label(third))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + f35cba72-07c5-4bd9-afbb-f0d2b22a2e65)(content(Whitespace\" \ + \")))))((Secondary((id \ + fe151c0c-ce3d-4bc9-9227-97e51a0aa3ac)(content(Whitespace\" \ + \"))))(Tile((id \ + 301abc18-7d85-4c67-b19a-152cf8dcd25b)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + b88a1c5f-dcd1-4974-93c9-826b1fa88d7d)(content(Whitespace\" \ + \"))))(Projector((id \ + a60622e3-bbe2-4d29-9081-97e4dc53e45b)(kind \ + Probe)(syntax(Tile((id \ + a60622e3-bbe2-4d29-9081-97e4dc53e45b)(label(x))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 921b48b9-f216-448b-be7a-5bee37cc4af8)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 45d7b101-b573-4aa9-9e2d-808f46c1472e)(content(Whitespace\" \ + \"))))(Secondary((id \ + 9c790c99-85f5-4161-a335-96a8cc16cd3a)(content(Whitespace\"\\n\"))))(Projector((id \ + efdbda6c-ad4a-45b0-9f7e-997608ce3f94)(kind \ + Probe)(syntax(Tile((id \ + efdbda6c-ad4a-45b0-9f7e-997608ce3f94)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + eb2ee1dc-1e4f-4613-92ff-7f3cd4a375dd)(label(fourth))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + fd9d5a3d-f0db-4d78-88da-c93cf444c040)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + a0d526c3-d5c5-4984-aed6-738444ac99d5)(label(x))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 175e08db-4d46-404b-82ee-ab6004481f6f)(content(Whitespace\" \ + \"))))(Tile((id \ + 6a0532d0-defa-41dd-9552-575ac03f5370)(label(/))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 69475242-7ac8-480b-b574-81086004e703)(content(Whitespace\" \ + \"))))(Tile((id \ + a8553361-f5a6-407c-a6b0-4c8f1737e6d0)(label(4))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 8d87988d-bd62-4b44-b5d9-74e41f5ab98c)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + ae8940e9-18ac-4881-8bcc-287818dbe598)(content(Whitespace\"\\n\"))))(Tile((id \ + d1ba74d0-8ed3-4a30-bacf-45bf2b2ef9d2)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + b7363479-109c-4cc8-b3be-81537f303114)(content(Whitespace\" \ + \"))))(Tile((id \ + c42b27f9-8833-4e4c-b0f0-266381abeeab)(label(second))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 1ec1a828-bcf9-4534-8e30-4f127d2e4138)(content(Whitespace\" \ + \")))))((Secondary((id \ + e9031146-cf7f-4ddf-9a10-9c631c8f5621)(content(Whitespace\" \ + \"))))(Tile((id \ + c6685701-3932-4485-a9ee-23efed57c09b)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 300d8def-9265-44f8-a3da-d622a8238fba)(content(Whitespace\" \ + \"))))(Projector((id \ + c0467909-6f41-4aa2-8722-a5c5aa5be074)(kind \ + Probe)(syntax(Tile((id \ + c0467909-6f41-4aa2-8722-a5c5aa5be074)(label(x))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 2ee1be25-dfef-4425-a25a-562425ba13c8)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 88a68b74-e6ac-4044-868f-639dc3e2551e)(content(Whitespace\" \ + \"))))(Secondary((id \ + ff092233-29e9-4a75-864b-6b1e1373262c)(content(Whitespace\"\\n\"))))(Projector((id \ + d8b80f6d-ca66-4f59-924d-f21193b089fa)(kind \ + Probe)(syntax(Tile((id \ + d8b80f6d-ca66-4f59-924d-f21193b089fa)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 83ff51e6-1fd8-4572-bb31-cc75ddd19674)(label(third))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 6890df9e-1759-4b95-90b2-c4314ff0b6df)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + f32f8e0a-1a4f-4cc2-bfe4-1e1873987429)(label(3))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 56670704-b1d7-49f1-b64a-ab605ca488f5)(content(Whitespace\" \ + \"))))(Tile((id \ + 47cbfa2a-dd14-426c-aaa5-8df036fef201)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 0e9b96d2-a5d3-4b48-b607-191952c18f2b)(content(Whitespace\" \ + \"))))(Tile((id \ + 87e818fe-7ef3-41f2-b80c-68ec3c721004)(label(x))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 5837d481-a939-4ef0-97fb-3fcdc94bb684)(content(Whitespace\" \ + \"))))(Tile((id \ + a6360712-cd42-40d9-b77c-da44be856ef5)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 1d1878cc-be40-4c1e-9093-9526004b14c2)(content(Whitespace\" \ + \"))))(Tile((id \ + 97b5e533-2669-4588-bada-2c62373f45fa)(label(1))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + e2b7dbca-a7b3-4774-abf0-59295bf517b0)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 8c5f4629-286a-4837-836b-6a3eca6e848a)(content(Whitespace\"\\n\"))))(Tile((id \ + 5ff3f001-e57c-457b-a793-e1ac39f36b01)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + fd4070e2-cd56-4900-a487-32d201315e17)(content(Whitespace\" \ + \"))))(Tile((id \ + ec9e7c80-bc99-4071-a462-436549d0e797)(label(first))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 8023e887-ef1e-46a1-be1b-f24ffb83c519)(content(Whitespace\" \ + \")))))((Secondary((id \ + e525abca-5049-45c8-aec4-4eee6e812953)(content(Whitespace\" \ + \"))))(Tile((id \ + 4add151a-e3b1-4e04-8dd7-b58328e4f040)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 04772292-fdc8-4b40-9a22-7138c6c9c065)(content(Whitespace\" \ + \"))))(Projector((id \ + 2377ec38-ac4f-4180-a208-7037db7754bc)(kind \ + Probe)(syntax(Tile((id \ + 2377ec38-ac4f-4180-a208-7037db7754bc)(label(x))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 30f629a3-ac23-4406-aada-20e87638273b)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 0f2deaeb-c710-4493-9e0e-b02f0933e5df)(content(Whitespace\" \ + \"))))(Secondary((id \ + 97b6f168-1755-4955-8ed9-67b282cb7967)(content(Whitespace\"\\n\"))))(Projector((id \ + 355ea9a0-0dcb-489f-8b65-a186ff68f6c8)(kind \ + Probe)(syntax(Tile((id \ + 355ea9a0-0dcb-489f-8b65-a186ff68f6c8)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 1b1adb02-c753-4c41-84f2-c0d7b1b7092e)(label(second))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 0a342842-94a0-48f8-b822-503599390f4a)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 76dc0878-125d-4bdc-abc3-e044ef2db8eb)(label(x))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + c0b40bd6-9bea-4bc8-a2aa-e581d586600d)(content(Whitespace\" \ + \"))))(Tile((id \ + 6afef7d4-2740-4462-a6bc-9861dcab73ff)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + b007c652-05d4-4102-9319-da7f135fcea3)(content(Whitespace\" \ + \"))))(Tile((id \ + ced6e1bf-64ac-4479-8eb0-b53abf9f112c)(label(2))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 98d68578-38c2-4791-a68f-14195d9e9ba9)(content(Whitespace\" \ + \"))))(Tile((id \ + 365455db-c825-4700-b86a-4aa0695cd7d3)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 87263b4a-bba0-495a-9b1e-f066feddc0c4)(content(Whitespace\" \ + \"))))(Tile((id \ + d91c14a5-9ca9-4cf3-8285-6410365e0114)(label(2))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + ca96f4e7-fc99-4654-8cd6-52493c01ae4a)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + b4442ac4-cbb9-44f5-9911-7f77a9cdfd7d)(content(Whitespace\"\\n\"))))(Tile((id \ + 3a7161f4-b180-46e6-afa1-b2b60ec23592)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 9b10dc8c-4963-43bf-a853-0d58f9f75ca7)(content(Whitespace\" \ + \"))))(Tile((id \ + 990196e5-4434-4a4f-81d2-cca3fc8991fe)(label(_))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + bf0b2396-b28a-42e1-969f-78149123646b)(content(Whitespace\" \ + \")))))((Secondary((id \ + 54ab0af8-d856-45de-9c20-6458245f75da)(content(Whitespace\" \ + \"))))(Projector((id \ + cd624e97-f51d-4310-b622-6eae20023b8b)(kind \ + Probe)(syntax(Tile((id \ + cd624e97-f51d-4310-b622-6eae20023b8b)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + e98de5e1-368d-4c62-87e2-70dc67bb07f6)(label(first))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + cebdb748-72e4-4d22-b5b7-dfdf2115bd5d)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + fb1c8aaf-7386-470e-a9f0-1c11697d676e)(label(5))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 5a49e6ff-bb58-49bd-93c9-4d1347d2f44e)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 75e108ca-3987-4705-b0ff-fd98eac3832d)(content(Whitespace\"\\n\"))))(Secondary((id \ + 10fdb2c6-6379-4f77-9411-feed6e730480)(content(Whitespace\"\\n\"))))(Secondary((id \ + 38f12425-72f2-4afc-9e8f-cf29ea159f7d)(content(Comment\"# \ + functions in functions #\"))))(Secondary((id \ + 8f0d3403-e3c7-410d-8054-cfccef303571)(content(Whitespace\"\\n\"))))(Tile((id \ + 5c8317fe-71eb-4888-921f-282519872b93)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 9c6914fd-ee0f-4dc7-8547-c6ea8e0c94fd)(content(Whitespace\" \ + \"))))(Tile((id \ + fbbfeb41-2a75-4052-bbc4-2d65ad38e586)(label(outer))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 1e8f222d-5f65-4827-b8f4-b96314a20ba7)(content(Whitespace\" \ + \")))))((Secondary((id \ + 5e1f2383-2e52-4fa1-994e-cfbe666a4dd5)(content(Whitespace\" \ + \"))))(Tile((id \ + c5dfe928-5571-47e5-81d3-f33d1b76f7bb)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 844a4e06-48a0-4d06-98f0-643f53638da7)(content(Whitespace\" \ + \"))))(Projector((id \ + 65038c37-8676-4e5f-8503-ada7771f4bd1)(kind \ + Probe)(syntax(Tile((id \ + 65038c37-8676-4e5f-8503-ada7771f4bd1)(label(y))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + f9b9146e-9253-4cdd-8610-14c83013ac34)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + bc350b60-c66e-483c-9d84-c668d3d2a98c)(content(Whitespace\"\\n\"))))(Tile((id \ + c033dba0-3c72-468c-a80e-12e1e2fc8010)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + b1103b7f-de2b-4784-9cfb-5500b2d49513)(content(Whitespace\" \ + \"))))(Projector((id \ + 6aa88bd5-aaa4-4887-85c1-fc95509f3a29)(kind \ + Probe)(syntax(Tile((id \ + 6aa88bd5-aaa4-4887-85c1-fc95509f3a29)(label(a))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 7f430bc0-901d-4d23-affc-377c7957c067)(content(Whitespace\" \ + \")))))((Secondary((id \ + 2c67587b-246f-4a7b-ae96-f68f6c2dc94b)(content(Whitespace\"\\n\"))))(Projector((id \ + 2eb8dc02-6f03-42ed-a12e-724f741ddc32)(kind \ + Probe)(syntax(Tile((id \ + 2eb8dc02-6f03-42ed-a12e-724f741ddc32)(label(10))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + f6641228-8da6-4a3f-8388-b81811b0dee8)(content(Whitespace\"\\n\"))))(Tile((id \ + 00309920-7129-49eb-91c1-aa779761937c)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 3e9c74fd-bd87-47d7-9cdb-e84ec281a8d2)(content(Whitespace\" \ + \"))))(Projector((id \ + 8416d273-f869-4b2d-8a92-d282559d0f31)(kind \ + Probe)(syntax(Tile((id \ + 8416d273-f869-4b2d-8a92-d282559d0f31)(label(y))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 59e9ecfd-8e8a-4b4d-a558-4585ba186b06)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + c459abe0-6c07-4b31-b3bc-571b7c52bf9a)(content(Whitespace\" \ + \"))))(Secondary((id \ + d0b3e592-ef8e-4f87-b930-37b761483036)(content(Whitespace\"\\n\"))))(Tile((id \ + dcd3480d-b336-43ca-a16a-d48f58648016)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + b3799582-de99-4061-b417-cf6d0896d33f)(content(Whitespace\" \ + \"))))(Tile((id \ + 16a9176a-35f0-4bc0-8fbe-00dc383830e2)(label(inner))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + b293c23d-c771-4551-bd8c-334c7b5dbac5)(content(Whitespace\" \ + \")))))((Secondary((id \ + 107f760c-f964-431e-bd87-4b3dfcf31c87)(content(Whitespace\" \ + \"))))(Tile((id \ + 42645903-c2bc-4138-9fec-d33cd389926c)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 65949c4d-4dc0-4213-9d7b-1e6f9681d5e1)(content(Whitespace\" \ + \"))))(Projector((id \ + c746675f-f2c5-4506-a061-1e6ca61bdf32)(kind \ + Probe)(syntax(Tile((id \ + c746675f-f2c5-4506-a061-1e6ca61bdf32)(label(z))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 688b7961-0d66-4bb9-89d3-2d8dbdba05a4)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + ac00f982-59ad-4d96-b2f7-132ea096ffcc)(content(Whitespace\"\\n\"))))(Projector((id \ + eb7847c4-281c-45b3-98eb-9d980453d225)(kind \ + Probe)(syntax(Tile((id \ + eb7847c4-281c-45b3-98eb-9d980453d225)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + b0d72243-ed26-4c70-b612-dddb92d99315)(label(a))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 12e1fbc2-5cdc-4b4c-bf95-2ead8a40c581)(content(Whitespace\" \ + \"))))(Tile((id \ + 7d982400-433e-46df-9b6d-9903a078b46b)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + df35a074-94c6-4d91-99c4-e6abe6d3cb02)(content(Whitespace\" \ + \"))))(Tile((id \ + bb62dca6-680d-4369-b185-1f67c8e95313)(label(2))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 901b33b8-2d77-4b42-85c6-f96f7c514c58)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Tile((id \ + 10bc86f5-9a3e-44f6-af1e-0cc3f4c34f3e)(label(z))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children())))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 09dc6a52-e3ae-40de-9e0e-b9522f4c7ea9)(content(Whitespace\" \ + \"))))(Secondary((id \ + 48554c58-500a-4c9b-929e-60fbd039100e)(content(Whitespace\" \ + \"))))(Secondary((id \ + d551eb83-6401-48e9-b315-cbac4d682338)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 5b730135-15e6-4322-8ed6-1a0b0ecb2cdd)(content(Whitespace\"\\n\"))))(Projector((id \ + a53be29e-095d-4d84-8994-82fba0135aa2)(kind \ + Probe)(syntax(Tile((id \ + a53be29e-095d-4d84-8994-82fba0135aa2)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 3c631b4c-254e-46c1-bb94-969299aca825)(label(inner))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 8b213872-054b-4b2e-b3c0-f65f22593ada)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + fe5a4c79-f803-429c-a63f-80e6020e9122)(label(3))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 9036ef14-9e80-4636-94b4-375dbaf30248)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Tile((id \ + 7a85c3e6-698a-43cc-8271-90ff1f94b970)(label(a))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 28bf3ad4-9820-446c-a349-797406667036)(content(Whitespace\"\\n\"))))(Tile((id \ + 46e0b99b-1cc4-42ca-92cf-7c7524b1197d)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 58457b4d-93fd-4a3c-bbb3-057100a0288e)(content(Whitespace\" \ + \"))))(Projector((id \ + bb7e8c82-548c-4929-968a-c36bf50e2112)(kind \ + Probe)(syntax(Tile((id \ + bb7e8c82-548c-4929-968a-c36bf50e2112)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + e6552a3e-0c4f-45c9-b755-cde3bc74a979)(label(inner))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 14ede4c3-6041-4a91-97e2-02ab0df83dfa)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + c56f4006-72d3-4ce4-acac-c2c8be6cf374)(label(5))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + b0c9ae3a-6c2b-46bc-8539-1f2b02d0cc08)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Tile((id \ + a349aba2-c83d-4787-915f-76713a370dbb)(label(y))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 3d699957-92da-4786-8d5b-564dcaf29a62)(content(Whitespace\" \ + \"))))(Secondary((id \ + fb590cb3-72e1-4d3c-8b9d-f496cda760b8)(content(Whitespace\" \ + \"))))(Secondary((id \ + b67f09f9-cc16-4290-9855-6c87f3586d13)(content(Whitespace\"\\n\")))))))))(Secondary((id \ + f0c7ccbd-0a24-46b9-939a-4dafbe1a02e0)(content(Whitespace\" \ + \"))))(Tile((id \ + 31590c3b-df44-4013-a78c-0cca198f1b4a)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 669c8db4-2c50-4950-91a8-3dc7eefbd7c9)(content(Whitespace\" \ + \"))))(Tile((id \ + fc1069d8-b5f7-4b89-9942-8fdcdaee62cf)(label(_))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 445206be-45be-4d9b-b11e-3a5225e8406b)(content(Whitespace\" \ + \")))))((Secondary((id \ + 49b98f40-e962-4440-8595-dac19922ab6e)(content(Whitespace\" \ + \"))))(Secondary((id \ + e179b26c-24ec-40d2-af7a-fca96781e212)(content(Whitespace\" \ + \"))))(Tile((id \ + 116bdadd-1916-4d9a-bee5-1070938cac88)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Secondary((id \ + b1cedbce-5bbb-41e3-9b19-b7c6875d5df6)(content(Whitespace\"\\n\"))))(Projector((id \ + 4c0af00f-fc68-4a0d-86a9-72ec21ca8142)(kind \ + Probe)(syntax(Tile((id \ + 4c0af00f-fc68-4a0d-86a9-72ec21ca8142)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 96f3d011-9e02-4c75-a73f-d1f924baa3d1)(label(outer))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 91b9e262-82b2-4a56-ac6c-ddcb4c62754c)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + a76f065e-380f-4b72-865f-588c68bbcbe2)(label(4))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Tile((id \ + a3532a75-ab50-4760-b986-a19f39892452)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 45))(sort \ + Exp))((shape(Concave 45))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + edae6488-6dfa-4876-b435-666b350c6b62)(content(Whitespace\"\\n\"))))(Projector((id \ + 165c1596-820f-4dee-9028-0b4d6eeb3054)(kind \ + Probe)(syntax(Tile((id \ + 165c1596-820f-4dee-9028-0b4d6eeb3054)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 1a39666a-1dca-4d6e-b444-0fda6766fdec)(label(outer))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + a8fd8565-3b2e-45a1-8164-71fa0a54335e)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 4dd547cd-1d0b-4a8e-b524-8c81506d90e0)(label(6))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Tile((id \ + 63e032f6-46c1-4250-8749-57f7c1ffa9f3)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 45))(sort \ + Exp))((shape(Concave 45))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 7cde06b6-a558-4b40-9055-4357ac977a32)(content(Whitespace\"\\n\"))))(Projector((id \ + e4b6e723-5940-49ab-9e3e-7f04de2e822c)(kind \ + Probe)(syntax(Tile((id \ + e4b6e723-5940-49ab-9e3e-7f04de2e822c)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 10dc6700-5e21-4721-95e8-6152a8cb1913)(label(outer))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 231add25-cd68-465f-b99f-9becbbf5b7ae)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 742a2288-24e2-4b82-aede-e2e5c81ab0f4)(label(a))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 5a16d272-742b-4feb-96a8-c78a634655c8)(content(Whitespace\" \ + \"))))(Tile((id \ + 1552efae-0c33-4d30-a8dc-30e35f9916be)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 1da56a90-47d2-41d4-989e-7ec684250003)(content(Whitespace\" \ + \"))))(Tile((id \ + 13a47487-7d84-47e6-9524-09ca44811475)(label(a))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + eab16292-9631-4d40-bac5-f6dfa036f85b)(content(Whitespace\"\\n\")))))))))(Secondary((id \ + ec0d8917-468f-46ac-92ca-a1f50907df0f)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 8fecb50f-2939-4937-978f-9db99e0947da)(content(Whitespace\"\\n\"))))(Secondary((id \ + e0601156-9921-41aa-a848-30d206c34d69)(content(Whitespace\"\\n\"))))(Secondary((id \ + 23fc887b-163e-4309-9982-bc89c07b81e9)(content(Comment\"# \ + branching #\"))))(Secondary((id \ + ec617d79-6b2a-496f-b577-11651b18a233)(content(Whitespace\"\\n\"))))(Tile((id \ + 64e70d57-37f8-4c26-9d96-e93dce34b19d)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 5f4da475-9c4f-40cd-b28d-5d0a83271dc0)(content(Whitespace\" \ + \"))))(Tile((id \ + 51045512-2211-4eaa-a7a5-4abc122c69f1)(label(cases))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + da286f66-e245-462a-9f82-d7af4913dd8b)(content(Whitespace\" \ + \")))))((Secondary((id \ + 167bba9e-d434-43b3-919f-58d57818cc4c)(content(Whitespace\"\\n\"))))(Tile((id \ + 91a3e37f-6e97-42bb-86d1-899ce0f1c112)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 0b9364b7-8bcd-410d-a9be-bc67630246ea)(content(Whitespace\" \ + \"))))(Projector((id \ + 960d1020-ad14-46c7-946f-d1a85906843b)(kind \ + Probe)(syntax(Tile((id \ + 960d1020-ad14-46c7-946f-d1a85906843b)(label(x))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 328be498-b7e3-4401-9df1-7f5c3c0ffa5c)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + e81fc6dd-20bd-4865-b899-2b99260827e0)(content(Whitespace\" \ + \"))))(Tile((id \ + 201cdcef-e896-4199-9dba-f87f5ac762b4)(label(case \ + end))(mold((out Exp)(in_(Rul))(nibs(((shape Convex)(sort \ + Exp))((shape Convex)(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + ef77471b-8e5c-4a50-b345-4ad02c3fd966)(content(Whitespace\" \ + \"))))(Tile((id \ + 12673ef7-6d7f-4cae-9175-1a433003dd6b)(label(x))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + df9d4d91-2da5-49d2-83e6-f1ba536584ac)(content(Whitespace\" \ + \"))))(Secondary((id \ + 4adcff49-20c7-46a1-9683-5c1e6f04f194)(content(Whitespace\"\\n\"))))(Tile((id \ + c02cf1ad-b800-4367-becc-8661f3f7d961)(label(| =>))(mold((out \ + Rul)(in_(Pat))(nibs(((shape(Concave 41))(sort \ + Exp))((shape(Concave 41))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 2067cd76-cbee-4e04-8fdf-8f335f18840d)(content(Whitespace\" \ + \"))))(Tile((id \ + fa2e864e-414c-4f09-81c8-0f728d187dc1)(label(4))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + c66c330b-48ca-427e-a7fc-4f26f4696e69)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + a4f0de02-2e1d-4539-89a5-6096f908b9cd)(content(Whitespace\" \ + \"))))(Projector((id \ + bb54c64a-5198-47d0-97c1-30595e61c599)(kind \ + Probe)(syntax(Tile((id \ + bb54c64a-5198-47d0-97c1-30595e61c599)(label(true))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 9c9992aa-37be-4d73-af70-bc6e7a7761f9)(content(Whitespace\"\\n\"))))(Tile((id \ + ae1f7d67-29bd-4f2e-9d1b-2d7fc742bcfa)(label(| =>))(mold((out \ + Rul)(in_(Pat))(nibs(((shape(Concave 41))(sort \ + Exp))((shape(Concave 41))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 3955f7ca-4578-486e-97a4-660e51182bcf)(content(Whitespace\" \ + \"))))(Tile((id \ + c64b1210-5a98-42ce-848e-ec6be545c255)(label(5))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 4622b447-3c22-42b4-b3f1-a7c990e1e679)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 5dc72c0f-1e62-4e78-9e96-91f028509f05)(content(Whitespace\" \ + \"))))(Projector((id \ + 88029932-8f98-4500-b451-340f66c0b5aa)(kind \ + Probe)(syntax(Tile((id \ + 88029932-8f98-4500-b451-340f66c0b5aa)(label(false))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 0cdedeee-73d8-4b05-b76c-abe487c41167)(content(Whitespace\"\\n\"))))(Tile((id \ + bd66fab0-c3e1-46d3-8f8b-f121ba570481)(label(| =>))(mold((out \ + Rul)(in_(Pat))(nibs(((shape(Concave 41))(sort \ + Exp))((shape(Concave 41))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 7210b1f8-6a7d-4e87-ba16-70d47ec88e2d)(content(Whitespace\" \ + \"))))(Tile((id \ + a8718a4b-a2f6-4b96-95b9-b3d7f570fd72)(label(_))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 2bb14b5b-e983-4325-a474-b3c4dddfefa0)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 4f582f57-38c0-43f6-9b84-c479f4ab37d6)(content(Whitespace\" \ + \"))))(Projector((id \ + 76fffbdd-2679-47e8-8e82-07672e58a9a1)(kind \ + Probe)(syntax(Tile((id \ + 76fffbdd-2679-47e8-8e82-07672e58a9a1)(label(true))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 390e5265-ff55-4b8e-81b1-45ac142cc61b)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 7d99f5d0-b4d6-43fb-bd9f-b0e39b2c1181)(content(Whitespace\" \ + \"))))(Secondary((id \ + 058fb841-3a1e-47aa-8f6e-c295dd237193)(content(Whitespace\"\\n\")))))))))(Secondary((id \ + 0a71ab58-0971-4057-8832-cd0fa7ed474a)(content(Whitespace\" \ + \"))))(Tile((id \ + 37e515ce-e02c-471f-9a61-8f64506cc814)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 0614710d-273c-4f99-a41f-39bad3141387)(content(Whitespace\" \ + \"))))(Tile((id \ + ddf38386-d7d9-43dc-a285-f779438361a2)(label(_))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + dace1707-208e-4ff2-85e6-4b94a49be6ff)(content(Whitespace\" \ + \")))))((Secondary((id \ + 9b052788-3f41-4a97-953c-6d731374dff0)(content(Whitespace\" \ + \"))))(Tile((id \ + 2077cb2f-6d94-428b-b734-c0ee915f7e8a)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Secondary((id \ + e949ced5-f756-4b92-a91f-6dc317b8b9f1)(content(Whitespace\"\\n\"))))(Projector((id \ + 7f1bad58-64ce-44d8-8445-578c63a6a796)(kind \ + Probe)(syntax(Tile((id \ + 7f1bad58-64ce-44d8-8445-578c63a6a796)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 23d6819f-65d3-49b9-b86d-b2e491e53979)(label(cases))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 328dd473-04d4-4277-9f69-5fed4ae6a9b3)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 3546c73b-0714-4d3e-bbbe-c9eb2766098c)(label(4))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Tile((id \ + 585cf1db-60be-4ade-98cc-6430807ed5d6)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 45))(sort \ + Exp))((shape(Concave 45))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 4f776d9a-2fee-4b79-86b5-21edbeebd90c)(content(Whitespace\"\\n\"))))(Projector((id \ + 601d967d-3408-4c38-aa3d-cfc1fefbdb13)(kind \ + Probe)(syntax(Tile((id \ + 601d967d-3408-4c38-aa3d-cfc1fefbdb13)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 2ec21ac9-0bea-405c-a447-8881a7b50343)(label(cases))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 88c5d630-41f7-4853-990d-98362157c526)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 2c435ab4-cfda-4112-8c21-e361afcc7173)(label(5))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Tile((id \ + a6c3decb-ac5a-49b4-a8f4-534c837b1943)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 45))(sort \ + Exp))((shape(Concave 45))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + db0c135d-ecc3-4989-b16e-402185094290)(content(Whitespace\"\\n\"))))(Projector((id \ + 148b0f50-6b23-47ce-b929-bba5b430cc54)(kind \ + Probe)(syntax(Tile((id \ + 148b0f50-6b23-47ce-b929-bba5b430cc54)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 8814b0a8-85c3-42e8-96ae-dd3f46f3048b)(label(cases))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 5831e5d5-ae89-44c7-8045-c212d091fece)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + e60a6b2b-ab79-4522-9685-66c61a67aced)(label(6))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 83599d4c-a3a7-40ec-9de0-d363918918f1)(content(Whitespace\"\\n\")))))))))(Secondary((id \ + b1b2fe71-47aa-4b7a-bb0a-f1031bc2ed58)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 803b1153-93dc-4548-b67e-63ff592b6c00)(content(Whitespace\"\\n\"))))(Secondary((id \ + ed717a7a-068b-4ef2-a808-0b2b182616ab)(content(Whitespace\"\\n\"))))(Secondary((id \ + 4cf408d7-e94a-4869-a538-dc89fa03ce2d)(content(Comment\"# \ + recursion #\"))))(Secondary((id \ + 5276808f-1f94-49d8-8a68-d35cf4d1375b)(content(Whitespace\"\\n\"))))(Tile((id \ + 953a0f2c-a18e-48ff-b8ab-4363443814bf)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 845a0640-839c-4649-b11c-298ac5e9f741)(content(Whitespace\" \ + \"))))(Tile((id \ + e24fa925-ec68-4477-b24c-85a3af462bdf)(label(fib))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ + 3fab4407-877d-4759-a203-19efbbe02a37)(label(:))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 23))(sort \ + Pat))((shape(Concave 23))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + 60b7e274-1ed2-4a92-8612-9edfe6387a1a)(content(Whitespace\" \ + \"))))(Tile((id \ + 20e6c6de-efa0-41d1-bbf7-9e9700550c88)(label(Int))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + 6fbbc886-38d3-4b76-8455-66ccce9e2738)(content(Whitespace\" \ + \"))))(Tile((id \ + 6d61eab8-4208-4749-a318-724cd760056f)(label(->))(mold((out \ + Typ)(in_())(nibs(((shape(Concave 13))(sort \ + Typ))((shape(Concave 13))(sort \ + Typ))))))(shards(0))(children())))(Secondary((id \ + b3f2c5b1-66c4-4d3a-9dd6-d9b07da3e121)(content(Whitespace\" \ + \"))))(Tile((id \ + e35cd85b-928e-48b9-9a48-c22ad3e394a9)(label(Int))(mold((out \ + Typ)(in_())(nibs(((shape Convex)(sort Typ))((shape \ + Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ + 039cea30-dbd8-481f-926b-b0bfd8d7456e)(content(Whitespace\" \ + \")))))((Secondary((id \ + 55e31bfc-9841-43fe-ba37-c09ab971dad8)(content(Whitespace\"\\n\"))))(Tile((id \ + 64995a45-4dba-4c4e-9382-79f573fba433)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 16d0f9c4-a401-4b0d-beb2-c915134e929a)(content(Whitespace\" \ + \"))))(Projector((id \ + 974da281-9d98-40a5-b7b2-da1ae9227191)(kind \ + Probe)(syntax(Tile((id \ + 974da281-9d98-40a5-b7b2-da1ae9227191)(label(x))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 87db44f1-5880-42ce-8f43-03ca4e33ce18)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 6e314be8-ef4d-48ba-826f-2e6d960e7f0e)(content(Whitespace\" \ + \"))))(Tile((id \ + 7bbb9c8c-989d-4fbd-be33-123a3c2f6d16)(label(case \ + end))(mold((out Exp)(in_(Rul))(nibs(((shape Convex)(sort \ + Exp))((shape Convex)(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 1b488629-e6a2-4865-a401-d387d73eb510)(content(Whitespace\" \ + \"))))(Tile((id \ + ff36ea5f-605f-44cc-a237-cec7d1340378)(label(x))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 6028432f-0dad-4d2e-9c08-616aab9bf8fe)(content(Whitespace\"\\n\"))))(Tile((id \ + 0cdc5e54-71c6-43d3-bd4f-16cf6d94218f)(label(| =>))(mold((out \ + Rul)(in_(Pat))(nibs(((shape(Concave 41))(sort \ + Exp))((shape(Concave 41))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 4eead0ed-8e3b-4524-88c3-6a4fcfcf99e2)(content(Whitespace\" \ + \"))))(Projector((id \ + d8ab6ddf-79bb-4350-9cf0-7d9c5f4fbbf2)(kind \ + Probe)(syntax(Tile((id \ + d8ab6ddf-79bb-4350-9cf0-7d9c5f4fbbf2)(label(0))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 915f9a2e-c34f-4b6c-8912-08dee95c4f49)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + b45c678f-12dc-4c4d-887b-c76cbc4e8704)(content(Whitespace\" \ + \"))))(Tile((id \ + c2443d47-fccf-4682-bacc-e5b90dbb4c9e)(label(1))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 1bad3366-c6a6-4b57-a9ce-ede407c987d6)(content(Whitespace\"\\n\"))))(Tile((id \ + 403bad8b-5549-4264-a2bf-2e8b22564ce2)(label(| =>))(mold((out \ + Rul)(in_(Pat))(nibs(((shape(Concave 41))(sort \ + Exp))((shape(Concave 41))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 4f6b1685-990f-48b4-8f36-d38c8b285223)(content(Whitespace\" \ + \"))))(Projector((id \ + 8891e6db-7340-4bee-8eca-0ae21dfa9ee3)(kind \ + Probe)(syntax(Tile((id \ + 8891e6db-7340-4bee-8eca-0ae21dfa9ee3)(label(1))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + f9c55ed4-5adf-4649-9b61-2b775ad340d7)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 74a7f9d5-6b59-4b2f-a43a-ee064dca5828)(content(Whitespace\" \ + \"))))(Tile((id \ + 107d2dbc-f3cd-4074-8b06-59f6626e53e7)(label(1))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 463fdd55-494f-413f-9ce9-9dc40a55890e)(content(Whitespace\"\\n\"))))(Tile((id \ + d71d3d18-6267-4240-8331-d23114501851)(label(| =>))(mold((out \ + Rul)(in_(Pat))(nibs(((shape(Concave 41))(sort \ + Exp))((shape(Concave 41))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 90667981-258e-4d09-ab33-b03958ad1246)(content(Whitespace\" \ + \"))))(Projector((id \ + b5152244-d625-4b5e-a946-f5ff545efc0d)(kind \ + Probe)(syntax(Tile((id \ + b5152244-d625-4b5e-a946-f5ff545efc0d)(label(n))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 7d1cadd0-e77f-4410-b644-27fdfb938852)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 39475c8e-4af0-4af1-ad59-6ac043416a44)(content(Whitespace\" \ + \"))))(Secondary((id \ + 237aacb0-5c9d-4d98-9d8a-0978c33c54d7)(content(Whitespace\" \ + \"))))(Secondary((id \ + f9f719ce-0db3-4a90-b2fe-202996b72912)(content(Whitespace\" \ + \"))))(Secondary((id \ + a2e1370d-263c-46ad-b102-e99d9b5fdbd3)(content(Whitespace\"\\n\"))))(Projector((id \ + 92889848-c7f6-48df-bafa-53fec43b90ca)(kind \ + Probe)(syntax(Tile((id \ + 92889848-c7f6-48df-bafa-53fec43b90ca)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + d9de4da9-55d2-4e14-822b-f49dbb46fa1c)(label(fib))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + d8502f58-3b20-4f50-a763-f6bdc272d84c)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + a6bc0c08-b088-40d0-89fb-7835d8990546)(label(x))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + dd9c851b-d4be-4129-9da7-491511610efd)(label(-))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Tile((id \ + 9c01433b-9d8b-4662-8420-3e7158516380)(label(1))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 9f5da5f3-8957-4dbd-b760-c2c654406f6c)(content(Whitespace\"\\n\"))))(Tile((id \ + 10ba6aec-a296-4616-9f66-c07bfc457389)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + e3805890-f33e-40f3-97a4-9042590b5751)(content(Whitespace\" \ + \"))))(Projector((id \ + 2a82dc5e-8758-4966-a2c7-f0bbe9eb3433)(kind \ + Probe)(syntax(Tile((id \ + 2a82dc5e-8758-4966-a2c7-f0bbe9eb3433)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + f0f88d79-9050-4669-b74b-1f3896ce404d)(label(fib))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 7e963d15-b543-4c12-b97f-1b9daabfc132)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + b72452ba-6de6-43c8-8c58-677d8d7e4c82)(label(x))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 46252f35-e75f-4e1e-97c0-cd970539ae4d)(label(-))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Tile((id \ + cd459c90-6a46-4cc2-a437-24048f37d510)(label(2))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 969e08d5-4db2-4515-82fb-fb6580de9838)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 38431bba-98f6-4973-aab9-19718f673035)(content(Whitespace\" \ + \"))))(Secondary((id \ + 74dd9640-2158-46ad-9268-ba1a6f2173f3)(content(Whitespace\"\\n\")))))))))(Secondary((id \ + 1dc924d0-84fb-44ca-abb6-265730fc500b)(content(Whitespace\" \ + \"))))(Tile((id \ + 8973c2ac-1e8e-48bd-9755-37acd220cbc5)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Secondary((id \ + 20f087ad-f08b-44c7-91df-86a49c1628f9)(content(Whitespace\"\\n\"))))(Projector((id \ + a5bc4575-9cfb-4990-97a8-c8c1e3f37b47)(kind \ + Probe)(syntax(Tile((id \ + a5bc4575-9cfb-4990-97a8-c8c1e3f37b47)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 4bd22e68-7383-44b2-a0a9-e43469d927a3)(label(fib))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + fc19962d-3a75-4e2f-af6d-95ad45c95512)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + c8f08840-15b5-4001-a2ba-63f4110a8285)(label(1))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Tile((id \ + b36314dc-8d7f-4943-b4ed-052e0e9ba4cc)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 45))(sort \ + Exp))((shape(Concave 45))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + ec75665c-f44b-417b-8c80-1084f7948e7c)(content(Whitespace\"\\n\"))))(Projector((id \ + 18b8ec42-6f93-44b2-9b05-3a74bbd0331c)(kind \ + Probe)(syntax(Tile((id \ + 18b8ec42-6f93-44b2-9b05-3a74bbd0331c)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + a9fb4968-1537-4a44-8bd4-b5553d78ea96)(label(fib))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 9b5c1b4e-389b-4b4f-854d-df134ec80b9b)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 94e01eb2-8664-4538-b814-ea92ff5d7e07)(label(2))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Tile((id \ + 3d1d994e-0e73-4375-a7b9-147ab384fcb2)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 45))(sort \ + Exp))((shape(Concave 45))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 4bcfc5c8-bff8-406e-804a-e308e12c58c0)(content(Whitespace\"\\n\"))))(Projector((id \ + 6b42473c-e83a-48fb-963c-34ac3b03e41f)(kind \ + Probe)(syntax(Tile((id \ + 6b42473c-e83a-48fb-963c-34ac3b03e41f)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 8a9685ca-5a3a-4870-86fd-e100f9602139)(label(fib))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 4ef8063e-8088-4532-835b-e12c465eb6e7)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 39c1385b-d3de-4a85-8262-9d0898e729d4)(label(3))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Tile((id \ + 35f6989e-6717-4141-bcea-48402069219d)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 45))(sort \ + Exp))((shape(Concave 45))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 90bcfb6c-d21c-47f2-a738-485ba16aea96)(content(Whitespace\"\\n\"))))(Projector((id \ + be1fef4e-077b-4e5b-9957-3c5f32400e18)(kind \ + Probe)(syntax(Tile((id \ + be1fef4e-077b-4e5b-9957-3c5f32400e18)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 8c507206-69ff-4adf-b480-5bae74758277)(label(fib))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 80464d32-cae5-4358-a33f-253529f7bf03)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 7654c4a3-164c-4a29-8bea-9381a60b3e08)(label(4))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))))))))))(ancestors())))(caret(Inner \ + 0 46)))"; + backup_text = + "# PROBE PROJECTORS #\n\n\ + # You can use the bottom-right projector panel #\n\ + # or alt/option-v (for value) to display live #\n\ + # values for an expression at the end of the #\n\ + # line. You can select any such value to see #\n\ + # any environment variables reference in the #\n\ + # probed expression. If the probed expression #\n\ + # is inside a function, the corresponding ap #\n\ + # (if also probed) will be filled in purple. #\n\ + # If the probed expression is an ap, values in #\n\ + # the relevant function definition closure, if #\n\ + # projected, will be outlined in purple. #\n\n\ + # top-level unconditional evaluation #\n\ + let a = (10 + 10) in\n\ + let b = (3 * a) in\n\n\ + # functions calling functions #\n\ + let fifth = fun x ->\n\ + (7*x) in\n\ + let fourth = fun x -> \n\ + (fifth(x - 4)) + 1 in\n\ + let third = fun x -> \n\ + (fourth(x)) / 4 in\n\ + let second = fun x -> \n\ + (third(3 * x)) + 1 in\n\ + let first = fun x -> \n\ + (second(x + 2)) * 2 in\n\ + let _ = (first(5)) in\n\n\ + # functions in functions #\n\ + let outer = fun y ->\n\ + let a =\n\ + 10\n\ + * y in \n\ + let inner = fun z ->\n\ + (a + 2*z) in\n\ + (inner(3*a))\n\ + + (inner(5*y)) \n\ + in let _ = (\n\ + (outer(4)),\n\ + (outer(6)),\n\ + (outer(a + a))\n\ + ) in\n\n\ + # branching #\n\ + let cases =\n\ + fun x -> case x \n\ + | 4 => true\n\ + | 5 => false\n\ + | _ => true end \n\ + in let _ = (\n\ + (cases(4)),\n\ + (cases(5)),\n\ + (cases(6))\n\ + ) in\n\n\ + # recursion #\n\ + let fib: Int -> Int =\n\ + fun x -> case x\n\ + | 0 => 1\n\ + | 1 => 1\n\ + | n => \n\ + (fib(x-1))\n\ + + (fib(x-2)) end \n\ + in (\n\ + (fib(1)),\n\ + (fib(2)),\n\ + (fib(3)),\n\ + (fib(4)))"; + } ); ( "Casting", { zipper = diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index 9bf169a278..af522a6df2 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -135,7 +135,8 @@ opacity: 100%; outline: 1px solid var(--TYP); } -.projector.probe .val-resize.cursor-lex.outer-ap .code-text { +.projector.probe .val-resize.cursor-outer-ap .code-text { + opacity: 100% !important; outline: 1px solid var(--TYP); background-color: var(--TYP); } @@ -179,7 +180,7 @@ .projector.probe .val-resize.cursor-ap-lex .code-text .token { color: var(--TYP); } -.projector.probe .val-resize.cursor-lex.outer-ap .code-text .token { +.projector.probe .val-resize.cursor-outer-ap .code-text .token { /* color: var(--TYP); */ color: white; } @@ -211,8 +212,6 @@ .projector.probe.indicated.Pat > svg { fill: var(--pat-indicated); } -.projector.probe.indicated:has(.main.ap) > svg { -} .projector.probe.indicated .main { color: white; From 2c211dd67a8ab72de39db4f23fe260a47cbb1676 Mon Sep 17 00:00:00 2001 From: disconcision Date: Tue, 14 Jan 2025 22:40:15 -0500 Subject: [PATCH 268/281] better probe doc slide --- src/haz3lcore/dynamics/Probe.re | 2 +- src/haz3lcore/zipper/projectors/ProbeProj.re | 23 +- src/haz3lweb/Init.ml | 2047 +++++++++++++----- 3 files changed, 1484 insertions(+), 588 deletions(-) diff --git a/src/haz3lcore/dynamics/Probe.re b/src/haz3lcore/dynamics/Probe.re index 5530c941da..3fb72610a1 100644 --- a/src/haz3lcore/dynamics/Probe.re +++ b/src/haz3lcore/dynamics/Probe.re @@ -23,7 +23,7 @@ type tag = [@deriving (show({with_path: false}), sexp, yojson)] type frame = { ap_id: Id.t, /* Syntax ID of the ap */ - env_id: Id.t /* ID of ClosureEnv created by ap */ + env_id: Id.t /* ID of env in which ap was applied */ }; /* List of applications prior to some evaluation */ diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index 063b5625ef..a57f0e9334 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -16,6 +16,7 @@ type model = { [@deriving (show({with_path: false}), sexp, yojson)] type action = + | PinAp(Id.t) | ChangeLength(Id.t, int) | Offset(int) | ToggleShowAllVals; @@ -70,6 +71,7 @@ let cur_outer_ap_id = (_info: info, dyn_stack: Probe.stack) => module State = { type t = { + mutable pinned_ap: option(Id.t), mutable env_cursor: list(Id.t), mutable dyn_env_cursor: list(Probe.frame), mutable cur_ap: option(Id.t), @@ -77,6 +79,7 @@ module State = { }; let s: t = { + pinned_ap: None, env_cursor: [], dyn_env_cursor: [], cur_ap: None, @@ -84,6 +87,7 @@ module State = { }; let reset = () => { + s.pinned_ap = None; s.env_cursor = []; s.dyn_env_cursor = []; s.cur_ap = None; @@ -155,7 +159,10 @@ let show_indicator = stack => { State.s.env_cursor == [] && local == [] || State.s.env_cursor != [] - && ListUtil.is_suffix_of(local, State.s.env_cursor); + && ( + ListUtil.is_suffix_of(local, State.s.env_cursor) + || ListUtil.is_suffix_of(State.s.env_cursor, local) + ); }; let dynamic_cursor_cls = (info: info, closure: Dynamics.Probe.Closure.t) => @@ -338,7 +345,7 @@ let offside_view = let num_closures = (info: info) => switch (info.dynamics) { | Some(di) => List.length(di) - | _ => 0 + | None => 0 }; let num_closures_view = (info: info) => { @@ -375,7 +382,11 @@ let view = ["main"] @ (Option.is_some(cur_ap_id(info)) ? ["ap"] : []), ), Attr.on_click(_ => { - State.reset(); + //State.reset(); + switch (State.s.pinned_ap) { + | Some(_) => State.s.pinned_ap = None + | None => State.s.pinned_ap = cur_ap_id(info) + }; Effect.Ignore; }), ], @@ -399,6 +410,12 @@ let update = (m: model, a: action) => { let index_offset = m.index_offset + offset; let index_offset = index_offset < 0 ? 0 : index_offset; {...m, index_offset}; + | PinAp(id) => + switch (State.s.pinned_ap) { + | Some(_) => State.s.pinned_ap = None + | None => State.s.pinned_ap = Some(id) + }; + m; }; }; diff --git a/src/haz3lweb/Init.ml b/src/haz3lweb/Init.ml index 866d778207..48d248a09b 100644 --- a/src/haz3lweb/Init.ml +++ b/src/haz3lweb/Init.ml @@ -78,57 +78,330 @@ let startup : PersistentData.t = zipper = "((selection((focus Left)(content())(mode \ Normal)))(backpack())(relatives((siblings(((Secondary((id \ - 2e4f396d-e2a8-4525-b002-7528f8ecf384)(content(Comment\"# \ - PROBE PROJECTORS #\"))))(Secondary((id \ + 65949c4d-4dc0-4213-9d7b-1e6f9681d5e1)(content(Whitespace\" \ + \")))))((Projector((id \ + c746675f-f2c5-4506-a061-1e6ca61bdf32)(kind \ + Probe)(syntax(Tile((id \ + c746675f-f2c5-4506-a061-1e6ca61bdf32)(label(z))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 688b7961-0d66-4bb9-89d3-2d8dbdba05a4)(content(Whitespace\" \ + \")))))))(ancestors((((id \ + 42645903-c2bc-4138-9fec-d33cd389926c)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort \ + Exp))))))(shards((0)(1)))(children(()())))(((Secondary((id \ + 107f760c-f964-431e-bd87-4b3dfcf31c87)(content(Whitespace\" \ + \")))))((Secondary((id \ + ac00f982-59ad-4d96-b2f7-132ea096ffcc)(content(Whitespace\"\\n\"))))(Projector((id \ + eb7847c4-281c-45b3-98eb-9d980453d225)(kind \ + Probe)(syntax(Tile((id \ + eb7847c4-281c-45b3-98eb-9d980453d225)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + b0d72243-ed26-4c70-b612-dddb92d99315)(label(a))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 12e1fbc2-5cdc-4b4c-bf95-2ead8a40c581)(content(Whitespace\" \ + \"))))(Tile((id \ + 7d982400-433e-46df-9b6d-9903a078b46b)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + df35a074-94c6-4d91-99c4-e6abe6d3cb02)(content(Whitespace\" \ + \"))))(Tile((id \ + bb62dca6-680d-4369-b185-1f67c8e95313)(label(2))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 901b33b8-2d77-4b42-85c6-f96f7c514c58)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Tile((id \ + 10bc86f5-9a3e-44f6-af1e-0cc3f4c34f3e)(label(z))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children())))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 09dc6a52-e3ae-40de-9e0e-b9522f4c7ea9)(content(Whitespace\" \ + \"))))(Secondary((id \ + 48554c58-500a-4c9b-929e-60fbd039100e)(content(Whitespace\" \ + \"))))(Secondary((id \ + d551eb83-6401-48e9-b315-cbac4d682338)(content(Whitespace\" \ + \")))))))(((id \ + dcd3480d-b336-43ca-a16a-d48f58648016)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards((0 \ + 1)(2)))(children((((Secondary((id \ + b3799582-de99-4061-b417-cf6d0896d33f)(content(Whitespace\" \ + \"))))(Tile((id \ + 16a9176a-35f0-4bc0-8fbe-00dc383830e2)(label(inner))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + b293c23d-c771-4551-bd8c-334c7b5dbac5)(content(Whitespace\" \ + \"))))))())))(((Secondary((id \ + 5e1f2383-2e52-4fa1-994e-cfbe666a4dd5)(content(Whitespace\" \ + \"))))(Tile((id \ + c5dfe928-5571-47e5-81d3-f33d1b76f7bb)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 844a4e06-48a0-4d06-98f0-643f53638da7)(content(Whitespace\" \ + \"))))(Projector((id \ + 65038c37-8676-4e5f-8503-ada7771f4bd1)(kind \ + Probe)(syntax(Tile((id \ + 65038c37-8676-4e5f-8503-ada7771f4bd1)(label(y))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + f9b9146e-9253-4cdd-8610-14c83013ac34)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 2ca1cc0b-a5f3-4d12-a288-d98f28f37215)(content(Whitespace\"\\n\"))))(Secondary((id \ + a7eb8274-d1c9-4902-b0b6-598bfadd11bb)(content(Comment\"# \ + Select `40` then `6` then '4' above. #\"))))(Secondary((id \ + bc350b60-c66e-483c-9d84-c668d3d2a98c)(content(Whitespace\"\\n\"))))(Tile((id \ + c033dba0-3c72-468c-a80e-12e1e2fc8010)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + b1103b7f-de2b-4784-9cfb-5500b2d49513)(content(Whitespace\" \ + \"))))(Projector((id \ + 6aa88bd5-aaa4-4887-85c1-fc95509f3a29)(kind \ + Probe)(syntax(Tile((id \ + 6aa88bd5-aaa4-4887-85c1-fc95509f3a29)(label(a))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 7f430bc0-901d-4d23-affc-377c7957c067)(content(Whitespace\" \ + \")))))((Secondary((id \ + 2c67587b-246f-4a7b-ae96-f68f6c2dc94b)(content(Whitespace\"\\n\"))))(Projector((id \ + 2eb8dc02-6f03-42ed-a12e-724f741ddc32)(kind \ + Probe)(syntax(Tile((id \ + 2eb8dc02-6f03-42ed-a12e-724f741ddc32)(label(10))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + f6641228-8da6-4a3f-8388-b81811b0dee8)(content(Whitespace\"\\n\"))))(Tile((id \ + 00309920-7129-49eb-91c1-aa779761937c)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 3e9c74fd-bd87-47d7-9cdb-e84ec281a8d2)(content(Whitespace\" \ + \"))))(Projector((id \ + 8416d273-f869-4b2d-8a92-d282559d0f31)(kind \ + Probe)(syntax(Tile((id \ + 8416d273-f869-4b2d-8a92-d282559d0f31)(label(y))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 59e9ecfd-8e8a-4b4d-a558-4585ba186b06)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + c459abe0-6c07-4b31-b3bc-571b7c52bf9a)(content(Whitespace\" \ + \"))))(Secondary((id \ + da68ac94-ca68-43b1-a9dd-2b3a9bdd4b54)(content(Whitespace\"\\n\"))))(Secondary((id \ + b61769e0-d6b7-463e-b9b0-c53f29885a80)(content(Comment\"# Note \ + how inside the `inner` function below #\"))))(Secondary((id \ + b9ccf427-f26b-41f2-82d6-84956cc49faf)(content(Whitespace\"\\n\"))))(Secondary((id \ + 40a2bbda-b3f5-48d1-89a5-c1074701cf66)(content(Comment\"# two \ + cells for each probe gets highlighted. #\"))))(Secondary((id \ + d0b3e592-ef8e-4f87-b930-37b761483036)(content(Whitespace\"\\n\")))))((Secondary((id \ + 0add31a6-9abc-463b-adfd-45c770508e85)(content(Whitespace\"\\n\"))))(Secondary((id \ + 0494dd90-9ee7-4648-85b2-dc4004cbc4c5)(content(Comment\"# This \ + is because there are two calls to `inner` \ + #\"))))(Secondary((id \ + 39c2b0c1-8429-493f-a1ae-5a99f0ec76fb)(content(Whitespace\"\\n\"))))(Secondary((id \ + 7cda68e9-d858-426d-965a-f1a08b6b0fae)(content(Comment\"# \ + below for each call to the containing `outer`. \ + #\"))))(Secondary((id \ + 5b730135-15e6-4322-8ed6-1a0b0ecb2cdd)(content(Whitespace\"\\n\"))))(Projector((id \ + a53be29e-095d-4d84-8994-82fba0135aa2)(kind \ + Probe)(syntax(Tile((id \ + a53be29e-095d-4d84-8994-82fba0135aa2)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 3c631b4c-254e-46c1-bb94-969299aca825)(label(inner))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 8b213872-054b-4b2e-b3c0-f65f22593ada)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + fe5a4c79-f803-429c-a63f-80e6020e9122)(label(3))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 9036ef14-9e80-4636-94b4-375dbaf30248)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Tile((id \ + 7a85c3e6-698a-43cc-8271-90ff1f94b970)(label(a))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 28bf3ad4-9820-446c-a349-797406667036)(content(Whitespace\"\\n\"))))(Tile((id \ + 46e0b99b-1cc4-42ca-92cf-7c7524b1197d)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 58457b4d-93fd-4a3c-bbb3-057100a0288e)(content(Whitespace\" \ + \"))))(Projector((id \ + bb7e8c82-548c-4929-968a-c36bf50e2112)(kind \ + Probe)(syntax(Tile((id \ + bb7e8c82-548c-4929-968a-c36bf50e2112)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + e6552a3e-0c4f-45c9-b755-cde3bc74a979)(label(inner))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 14ede4c3-6041-4a91-97e2-02ab0df83dfa)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + c56f4006-72d3-4ce4-acac-c2c8be6cf374)(label(5))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + b0c9ae3a-6c2b-46bc-8539-1f2b02d0cc08)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Tile((id \ + a349aba2-c83d-4787-915f-76713a370dbb)(label(y))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 3d699957-92da-4786-8d5b-564dcaf29a62)(content(Whitespace\" \ + \"))))(Secondary((id \ + fb590cb3-72e1-4d3c-8b9d-f496cda760b8)(content(Whitespace\" \ + \"))))(Secondary((id \ + b67f09f9-cc16-4290-9855-6c87f3586d13)(content(Whitespace\"\\n\")))))))(((id \ + 5c8317fe-71eb-4888-921f-282519872b93)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards((0 \ + 1)(2)))(children((((Secondary((id \ + 9c6914fd-ee0f-4dc7-8547-c6ea8e0c94fd)(content(Whitespace\" \ + \"))))(Tile((id \ + 15450cd3-306b-46a0-8575-1a682d4ed4ba)(label(outer))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 1e8f222d-5f65-4827-b8f4-b96314a20ba7)(content(Whitespace\" \ + \"))))))())))(((Secondary((id \ + 5b287b8d-cee1-4a37-be6d-22512f83a127)(content(Comment\"# \ + _____ _ #\"))))(Secondary((id \ + 67bc4c20-c62a-4db7-af01-908216b0d940)(content(Whitespace\"\\n\"))))(Secondary((id \ + 208c6dd4-02d1-431d-b694-e4487e1a0e95)(content(Comment\"# | \ + __ \\\\ | | #\"))))(Secondary((id \ + d2944d23-8ca9-4970-a985-40ab2b4a3af6)(content(Whitespace\"\\n\"))))(Secondary((id \ + 2d1074c0-2026-43fb-8398-cc639139d863)(content(Comment\"# | \ + |__) | __ ___ | |__ ___ ___ #\"))))(Secondary((id \ + 0ef82daa-6f9d-4ab5-8d54-f7d664752484)(content(Whitespace\"\\n\"))))(Secondary((id \ + 6caa8137-8b42-4169-934d-55d736d46de4)(content(Comment\"# | \ + ___/ '__/ _ \\\\| '_ \\\\ / _ \\\\/ __| #\"))))(Secondary((id \ + ee5947db-81ec-4ffb-b124-827e4dbc67a1)(content(Whitespace\"\\n\"))))(Secondary((id \ + 0cd2ec95-039a-4ca1-bddd-14a859fd7cdb)(content(Comment\"# | \ + | | | | (_) | |_) | __/\\\\__ \\\\ #\"))))(Secondary((id \ + 7ece1d07-c40a-44d4-bb4f-14419a6e16c8)(content(Whitespace\"\\n\"))))(Secondary((id \ + dfe91edb-50c5-40d0-aecc-e122780c0a63)(content(Comment\"# \ + |_| |_| \\\\___/|_.__/ \\\\___||___/ #\"))))(Secondary((id \ + 2fc4d2b0-e375-4812-b252-48f0892762d1)(content(Whitespace\"\\n\"))))(Secondary((id \ + 6b44f0c9-c83a-4cd8-a951-c34047838729)(content(Comment\"# \ + INLINE EVAL WITH PROBE PROJECTORS #\"))))(Secondary((id \ + cf887ddd-6849-4677-81c3-5bfe475fb383)(content(Whitespace\"\\n\"))))(Secondary((id \ + da7e9cb5-374c-4c7c-b8a5-9d59dea54161)(content(Whitespace\"\\n\"))))(Secondary((id \ + 3b244ca5-7533-4047-978c-be08d8f22508)(content(Comment\"# \ + INTRODUCTION #\"))))(Secondary((id \ 8210bd57-34f5-4158-ab9b-10fabe1df80f)(content(Whitespace\"\\n\"))))(Secondary((id \ 2f48cdfc-e0e5-45ed-a455-34d63b4b1399)(content(Whitespace\"\\n\"))))(Secondary((id \ - 1a171974-2aa0-4b9d-9806-83a849ad3845)(content(Comment\"# You \ - can use the bottom-right projector panel \ + 65248bf0-b96b-4e77-a1cb-ed9bf22848fc)(content(Comment\"# \ + Probe projectors are a kind of inline evaluation, \ + #\"))))(Secondary((id \ + a25a5f30-6ab3-4a2a-839b-9f37efc20e7e)(content(Whitespace\"\\n\"))))(Secondary((id \ + ab6bef21-8e63-4167-aeab-5e055374279d)(content(Comment\"# \ + similar to value hints in Emacs or IntelliJ. \ + #\"))))(Secondary((id \ + f804062f-ceec-446b-beec-472f2f273213)(content(Whitespace\"\\n\"))))(Secondary((id \ + e7e85b2a-a8cc-4980-b759-c645577c9ec5)(content(Whitespace\"\\n\"))))(Secondary((id \ + ae0cbe88-9816-4caf-b4d0-e231c5cca2de)(content(Comment\"# You \ + can put these on any expression or variable binding to \ + #\"))))(Secondary((id \ + 33a8036d-74f2-4a34-9c0a-b8736aef5c01)(content(Whitespace\"\\n\"))))(Secondary((id \ + 0ca100bf-048d-4907-a81d-70b71cde7ba8)(content(Comment\"# see \ + a list of all values taken on by that expression/pattern. \ #\"))))(Secondary((id \ - 52056d3d-8b89-4ec7-a8c6-843266b2f64b)(content(Whitespace\"\\n\"))))(Secondary((id \ - 3a01b224-cd29-4480-b316-2cd539c42fea)(content(Comment\"# or \ - alt/option-v (for value) to display live \ + 33af093f-99de-41c6-9b7e-c6de31d474a7)(content(Whitespace\"\\n\"))))(Secondary((id \ + cafc993b-67f5-4c12-bf7a-97a479dc5fc8)(content(Comment\"# By \ + default values are sorted by left-to-right by most-recent. \ #\"))))(Secondary((id \ - fa40e230-71dc-46f5-8746-f063ad5327b8)(content(Whitespace\"\\n\"))))(Secondary((id \ - 7969ef21-db02-4b6f-b49e-0ae8d97d242f)(content(Comment\"# \ - values for an expression at the end of the \ + ed8a120e-3a98-4e92-a3e2-f5111facd461)(content(Whitespace\"\\n\"))))(Secondary((id \ + 176d3c71-e66d-4dd8-9bca-6c6cf34bab56)(content(Whitespace\"\\n\"))))(Secondary((id \ + 657b42ce-5031-4164-adfe-b21d8f65c518)(content(Comment\"# More \ + generally, each cell represents a stack state, \ #\"))))(Secondary((id \ - 2e489ec0-ff78-4d00-a139-a7a833ed0b81)(content(Whitespace\"\\n\"))))(Secondary((id \ - cdbf03bb-f995-47dc-bb2f-0e6250633fac)(content(Comment\"# \ - line. You can select any such value to see \ + 3c91844a-c185-4c0d-aa09-61e7721e31f0)(content(Whitespace\"\\n\"))))(Secondary((id \ + c8281cbd-49ba-4c0f-856e-0ba07786528e)(content(Comment\"# \ + including the top stack frame / closure and hence the \ #\"))))(Secondary((id \ - 7eb272cf-da0a-4193-a819-b998d9274d4d)(content(Whitespace\"\\n\"))))(Secondary((id \ - 27298240-100e-45e5-8444-45e4b0b8312d)(content(Comment\"# any \ - environment variables reference in the \ + 910d4431-8fd5-4460-919f-48373f98b3ef)(content(Whitespace\"\\n\"))))(Secondary((id \ + bf08867d-99b2-4e0a-a5bb-e6a842a00965)(content(Comment\"# \ + expression's value, the values of environment variables, \ #\"))))(Secondary((id \ - 27e1f5f5-24fd-4fd1-91e4-69254cac160a)(content(Whitespace\"\\n\"))))(Secondary((id \ - b298f390-af63-4b4c-8afd-8b1a4f7c07eb)(content(Comment\"# \ - probed expression. If the probed expression \ + 0bd2f997-3ce5-4fa3-ad04-cbd7539ae614)(content(Whitespace\"\\n\"))))(Secondary((id \ + 6595a069-f601-42a4-aa86-a6d221193d7d)(content(Comment\"# as \ + well as the surrounding call stack context. \ #\"))))(Secondary((id \ - afbdbd3a-1168-4931-802e-ec61e328e497)(content(Whitespace\"\\n\"))))(Secondary((id \ - 84a18224-b099-4c5a-8823-48cc8ce34c3e)(content(Comment\"# is \ - inside a function, the corresponding ap \ + fe09e076-6943-4980-bcb6-51783cb66928)(content(Whitespace\"\\n\"))))(Secondary((id \ + 6882dbea-dcef-478b-8103-90720fac77fc)(content(Whitespace\"\\n\"))))(Secondary((id \ + 195a40ec-d2b7-4356-933a-2c88cc6f3f9e)(content(Comment\"# When \ + a cell is selected, you can hover over it to see \ #\"))))(Secondary((id \ - b678ca9c-e22c-421c-bab5-709a52e99fb4)(content(Whitespace\"\\n\"))))(Secondary((id \ - 6956379a-5db1-456d-aca5-5380be9c27a1)(content(Comment\"# (if \ - also probed) will be filled in purple. \ + 61b2d5b1-c3fb-4625-b1f9-ac5c0a51a193)(content(Whitespace\"\\n\"))))(Secondary((id \ + acd47988-36ff-496a-b41f-27b842766165)(content(Comment\"# \ + relevant environment variables, and all /other/ cells \ #\"))))(Secondary((id \ - 530b3a8e-48f0-4554-b6c1-c95d01cec00e)(content(Whitespace\"\\n\"))))(Secondary((id \ - e4135573-5dd6-4859-8b12-0e964657e404)(content(Comment\"# If \ - the probed expression is an ap, values in \ + 2911123d-3700-4cd3-8985-ca6bb5467c35)(content(Whitespace\"\\n\"))))(Secondary((id \ + d2fb50cb-1567-41d1-a42a-d3d787a07e12)(content(Comment\"# are \ + decorated according to their relative position in \ #\"))))(Secondary((id \ - 9e630698-940e-45b8-b9da-d98a2ff33b8e)(content(Whitespace\"\\n\"))))(Secondary((id \ - 20f63e20-270f-4df3-8977-3cc6996158ed)(content(Comment\"# the \ - relevant function definition closure, if \ + 21198096-1ba1-469f-a669-85ff3b253173)(content(Whitespace\"\\n\"))))(Secondary((id \ + a64163a4-22fa-435c-8e94-28a3a7808b73)(content(Comment\"# to \ + the selected cell. in the context #\"))))(Secondary((id \ + f6f614fc-2bc6-44e9-a772-df4349410ad4)(content(Whitespace\"\\n\"))))(Secondary((id \ + 3f732f1e-718d-4eee-b0f4-bd139ba927c7)(content(Whitespace\"\\n\"))))(Secondary((id \ + 06843876-589e-44ca-aacb-9ebd7377f788)(content(Comment\"# \ + Probe are intended mostly as a println replacement \ #\"))))(Secondary((id \ - b82ce1da-ab03-4be3-ab8a-af5dc191411f)(content(Whitespace\"\\n\")))))((Secondary((id \ - b885bff9-5c5b-457a-a96b-acb19ec3f2a7)(content(Comment\"# \ - projected, will be outlined in purple. \ + f5162412-6db0-49b2-94b1-3d1974967ad0)(content(Whitespace\"\\n\"))))(Secondary((id \ + a0d4fd1d-bb6e-49f4-b590-d1ee57d12991)(content(Comment\"# for \ + exposing intermediate values, with the above decorations \ #\"))))(Secondary((id \ - fe0c955d-8296-475e-8ef4-82bdc988d2ab)(content(Whitespace\"\\n\"))))(Secondary((id \ + a59859da-5b5f-4c0f-9926-21bd62fbf4d2)(content(Whitespace\"\\n\"))))(Secondary((id \ + 654b4955-23bd-4864-99cc-be8741944aa3)(content(Comment\"# as a \ + supporting feature to help maintain context when \ + #\"))))(Secondary((id \ + 2983735d-9145-4f8a-9322-32b60bd14f3d)(content(Whitespace\"\\n\"))))(Secondary((id \ + a6c54746-4de4-4c92-b65d-a3ade86e060c)(content(Comment\"# \ + navigating between multiple probed expressions, which \ + #\"))))(Secondary((id \ + 8bf15a15-ea96-46c2-b315-2cc3f86f15fb)(content(Whitespace\"\\n\"))))(Secondary((id \ + a0f07411-7fe4-49dc-8088-ac0c3d7e296f)(content(Comment\"# may \ + take on many values across nested or recursive functions. \ + #\"))))(Secondary((id \ + 7c147ac0-b6ad-4279-aeaf-d36b5416f392)(content(Whitespace\"\\n\"))))(Secondary((id \ + bc968ebb-e86f-44a0-974f-d339055c1130)(content(Whitespace\"\\n\"))))(Secondary((id \ + ac49c56a-e570-41ad-b1e4-9a3833db1853)(content(Whitespace\"\\n\"))))(Secondary((id \ + bbdb30b4-5827-4173-a8e7-d789dca85f95)(content(Comment\"# \ + TUTORIAL #\"))))(Secondary((id \ + 58a09c39-f68c-4218-90ce-55e2680b08f2)(content(Whitespace\"\\n\"))))(Secondary((id \ 4346c13e-3c97-47b8-895f-1847a9d118fd)(content(Whitespace\"\\n\"))))(Secondary((id \ - deadf426-81c0-4a06-91ca-197171ee3560)(content(Comment\"# \ - top-level unconditional evaluation #\"))))(Secondary((id \ + fa1f17d0-e7be-4578-8e81-32db9ecc9912)(content(Comment\"# The \ + expression (10 * 10) below has a probe. \ + #\"))))(Secondary((id \ + ecc94b58-cbb0-494d-936e-6c900d510bb6)(content(Whitespace\"\\n\"))))(Secondary((id \ + 6d365200-9122-4671-a1b2-8f6489691f84)(content(Comment\"# Its \ + value, 20, is shown in a cell to the right. \ + #\"))))(Secondary((id \ 76885278-d622-4dcf-8e4c-79c44a75a0ef)(content(Whitespace\"\\n\"))))(Tile((id \ 3000d752-d923-409e-8e67-8e010d9c9563)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ @@ -136,7 +409,7 @@ let startup : PersistentData.t = 2))(children(((Secondary((id \ 647dd5f0-1cc3-4462-967d-4548c7f2ea58)(content(Whitespace\" \ \"))))(Tile((id \ - 367d4582-534e-4ff7-b673-0b1feb804250)(label(a))(mold((out \ + b2801029-9a24-4a2c-b399-6a94ea5793fb)(label(sum))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ f8e8d3af-8167-4f18-a675-1f1ce4f61477)(content(Whitespace\" \ @@ -166,6 +439,81 @@ let startup : PersistentData.t = 30)(index_offset 0))\")))(Secondary((id \ 8b1fc809-5b94-4340-b403-f642f7ee12c1)(content(Whitespace\" \ \")))))))))(Secondary((id \ + 7c0da59a-85c9-41ec-b523-62d721849a48)(content(Whitespace\"\\n\"))))(Secondary((id \ + bb1b4aff-55bb-447c-9d16-ce5dc2617125)(content(Whitespace\"\\n\"))))(Secondary((id \ + ab255a91-92e1-42a9-9bae-54fac4df120f)(content(Comment\"# To \ + probe the below expression, put your caret to \ + #\"))))(Secondary((id \ + e845151d-6227-4353-af30-3e2bf74929d2)(content(Whitespace\"\\n\"))))(Secondary((id \ + 13446dd5-7c48-4205-968d-0a2c27660f32)(content(Comment\"# left \ + of the `(` and press option/alt-v (for value), \ + #\"))))(Secondary((id \ + cf530abf-7e7b-4255-8c62-e44c846fdd33)(content(Whitespace\"\\n\"))))(Secondary((id \ + 95bcffe5-c814-49cf-bd56-f82ab29bf1b2)(content(Comment\"# or \ + select `Probe` from the lower right corner menu: \ + #\"))))(Secondary((id \ + d4261756-48f5-48ef-a17d-de4435e3a330)(content(Whitespace\"\\n\"))))(Tile((id \ + 8b094a53-f8d0-44c8-a7a7-a22f29754490)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 9ebe9a8e-4c1e-4886-9974-9851ded32cfe)(content(Whitespace\" \ + \"))))(Tile((id \ + 34de50bd-fb16-411f-97e2-ae068e6d893b)(label(drink_me))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + ee1c01a4-bcbb-42b3-aa57-02a387f3c535)(content(Whitespace\" \ + \")))))((Secondary((id \ + 647d6520-b2aa-49eb-a0f6-284db9852848)(content(Whitespace\" \ + \"))))(Tile((id \ + 9b252383-4162-4def-a7ff-69489a182c12)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 8ed001eb-a891-432f-88c6-07d619237e34)(label(1))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 4d505eab-49b5-4cde-8aa3-06def5a3ed57)(content(Whitespace\" \ + \"))))(Tile((id \ + e3048ce1-b7ab-4492-a0ce-c1a260293bc1)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 33053c39-e296-4080-bfcd-7a829a2c97be)(content(Whitespace\" \ + \"))))(Tile((id \ + 224bb15c-5a60-42d3-b8d1-04dbdccc88a0)(label(2))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 56501795-b884-4b3c-9126-3311b9f8f3d9)(content(Whitespace\" \ + \"))))(Tile((id \ + 3599233c-5d4f-4991-a2d3-e387726e1974)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 22c6bfb1-04f8-4fee-b0fc-0d03a72e87aa)(content(Whitespace\" \ + \"))))(Tile((id \ + dba64d67-0efa-418f-a25b-f07fe8f54215)(label(3))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))(Secondary((id \ + 700a419e-6219-4b06-8eda-dd76ef32df96)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 47eb8a96-9cfc-4852-b7a1-e5eba861d75d)(content(Whitespace\"\\n\"))))(Secondary((id \ + 3725c352-6550-4086-99fb-2b79297052d3)(content(Comment\"# The \ + expression should be encased in a green block \ + #\"))))(Secondary((id \ + a8efa47c-f665-490c-b305-dc5fd620b1d7)(content(Whitespace\"\\n\"))))(Secondary((id \ + 1d976db7-fdf3-48e2-aa5f-e0b078a356de)(content(Comment\"# and \ + a cell reading `7` should appear to the right. \ + #\"))))(Secondary((id \ + 5c540111-c7d3-4e23-85d2-cf35e42d74b6)(content(Whitespace\"\\n\"))))(Secondary((id \ + 8cfbab20-e70b-41c4-9040-b23b7721c624)(content(Comment\"# The \ + same shortcut or menu toggle removes it. \ + #\"))))(Secondary((id \ + f422f7d0-6c78-4d2c-bff3-b2771a69d07b)(content(Whitespace\"\\n\"))))(Secondary((id \ + 8fea3b87-a12d-4c66-baba-312e33ec6138)(content(Whitespace\"\\n\"))))(Secondary((id \ + 9853138b-27f5-4ea2-8221-c4e0867d0ebc)(content(Comment\"# \ + Click the below cell (with value 60) to select it. \ + #\"))))(Secondary((id \ 8f886a2e-412c-431d-9995-fdab6b02b6ca)(content(Whitespace\"\\n\"))))(Tile((id \ f9853e31-5aa7-44dd-a82e-af03a8ee5b70)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ @@ -173,7 +521,7 @@ let startup : PersistentData.t = 2))(children(((Secondary((id \ b9f34a21-57ea-4edd-9182-d65a1379602c)(content(Whitespace\" \ \"))))(Tile((id \ - 2b80a8b0-6825-4dbf-b7c7-a7a789b0dc74)(label(b))(mold((out \ + 196da6fc-fc11-4cd1-b9ff-8d800939635c)(label(thrice))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ 0e936f30-84e4-4d24-b1d8-95d5ff287339)(content(Whitespace\" \ @@ -196,863 +544,1237 @@ let startup : PersistentData.t = Exp))))))(shards(0))(children())))(Secondary((id \ 57872b2c-1bf1-4a7f-babe-2e8788ea4efd)(content(Whitespace\" \ \"))))(Tile((id \ - 5e1f59ef-ed4d-430b-af7a-ace19e85c189)(label(a))(mold((out \ + 4833e983-f57f-4556-884a-dad25d4f3d9a)(label(drink_me))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ Exp))))))(shards(0))(children())))))))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ a6eebd77-67a0-43d5-bd3b-49cfc50fbbe1)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 0e6bf9c6-5ce8-44c8-94c3-78096f46b6ec)(content(Whitespace\"\\n\"))))(Secondary((id \ - d046139b-ab4f-43e6-90d0-5bdfe3fc8091)(content(Whitespace\"\\n\"))))(Secondary((id \ - 4f7b03f0-00d1-4425-af0b-6827cecbe29b)(content(Comment\"# \ - functions calling functions #\"))))(Secondary((id \ - 2c5deea0-6860-4ae6-8baa-62791e7a2e89)(content(Whitespace\"\\n\"))))(Tile((id \ - a137c9ef-2d61-4ee9-bb17-d9dda9b2a847)(label(let = \ + 0ce9af82-59fc-49ed-86b9-f881a345913f)(content(Whitespace\"\\n\"))))(Secondary((id \ + b1772155-740a-49ef-a716-c02399cc1475)(content(Comment\"# \ + Notice when you hover over a selected cell, it \ + #\"))))(Secondary((id \ + 40025529-bba9-4742-9cb3-ab9813cd1e06)(content(Whitespace\"\\n\"))))(Secondary((id \ + efea37d3-bcfa-459e-9391-056fceba8584)(content(Comment\"# \ + shows the values of any contained variables. \ + #\"))))(Secondary((id \ + 84f13d8b-b3b3-49b6-a27f-e4ac5eba08ac)(content(Whitespace\"\\n\"))))(Secondary((id \ + 7ea42771-8218-481e-b490-714cb9c18f7a)(content(Whitespace\"\\n\"))))(Secondary((id \ + 41f6c6e5-c2ab-40ad-b4fa-53f034cbb5c5)(content(Comment\"# \ + Probes only have cells if the are evaluated. \ + #\"))))(Secondary((id \ + 40b30a8c-27a1-4a28-ae92-bbd6acbd47ca)(content(Whitespace\"\\n\"))))(Secondary((id \ + d0a3973a-f575-4a46-80d4-c18f4fe6f8de)(content(Comment\"# \ + Below, only the first case branch is evaluated. \ + #\"))))(Secondary((id \ + cf4c7749-cf95-465a-be97-2fc2cc652429)(content(Whitespace\"\\n\"))))(Tile((id \ + 66aae668-dbb8-4197-b0de-e7586e058ab2)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ 2))(children(((Secondary((id \ - 1acce041-c1d4-4f4b-b18f-62977e8355fb)(content(Whitespace\" \ + 816df199-6a01-4285-8d5c-306901774c37)(content(Whitespace\" \ \"))))(Tile((id \ - 3bac31bd-00dd-471c-9a51-bf901ebe36b5)(label(fifth))(mold((out \ + 5f975019-a8f6-44b1-b5e5-bc49f793191e)(label(maybe))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - a9835df3-b589-47a8-8444-e59b3aa93f90)(content(Whitespace\" \ + be4553fa-e053-4203-ba56-3256834ee4f8)(content(Whitespace\" \ \")))))((Secondary((id \ - ce3bf749-cf23-4fd7-ac92-0afac717100a)(content(Whitespace\" \ + 66a3ee43-195f-4d63-b879-f08752a9733c)(content(Whitespace\" \ \"))))(Tile((id \ - ef90a214-bb3f-46e7-ac4f-8189a8b0c912)(label(fun \ - ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ - 1))(children(((Secondary((id \ - 4798d1b8-a19d-4827-aeb7-021c229b5692)(content(Whitespace\" \ + 075467c3-5185-4f42-9397-77eebcd666ba)(label(if then \ + else))(mold((out Exp)(in_(Exp Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 34))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 97112299-6dd3-44aa-b208-057637c540b2)(content(Whitespace\" \ \"))))(Projector((id \ - c97e794e-a61c-444d-a64c-1392b495128e)(kind \ - Probe)(syntax(Tile((id \ - c97e794e-a61c-444d-a64c-1392b495128e)(label(x))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + 5e7b39cd-f3ac-42e4-9dcc-849236c0a59d)(kind \ + Checkbox)(syntax(Tile((id \ + 5e7b39cd-f3ac-42e4-9dcc-849236c0a59d)(label(true))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ - Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Secondary((id \ - ec63e8ad-0fdd-45bd-8e49-0005240ef297)(content(Whitespace\" \ + Exp))))))(shards(0))(children()))))(model\"()\")))(Secondary((id \ + 082ef8dc-afea-4e77-a812-594fd3141a87)(content(Whitespace\" \ + \")))))((Secondary((id \ + 5ec5e6bd-2231-4ef4-9b0a-df5bb4e9251a)(content(Whitespace\" \ + \"))))(Tile((id \ + 2b4e9ea3-0e74-4b17-bb68-a40a5cb502c6)(label(thrice))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 6fe14abb-3959-4260-8e94-7310d821a7a9)(content(Whitespace\" \ \")))))))))(Secondary((id \ - e42f841a-9953-4a78-8433-754794af8049)(content(Whitespace\"\\n\"))))(Projector((id \ - cc0f99f4-f669-4e09-ab49-c8c61137ef8a)(kind \ - Probe)(syntax(Tile((id \ - cc0f99f4-f669-4e09-ab49-c8c61137ef8a)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - cc5ea4b9-c3fa-4305-b837-edb87668f9fe)(label(7))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - c31e4832-1dde-469e-9a0a-33f1006115e7)(label(*))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 26))(sort \ - Exp))((shape(Concave 26))(sort \ - Exp))))))(shards(0))(children())))(Tile((id \ - 3dcae31b-3062-40f7-a8db-5e1fde407235)(label(x))(mold((out \ + 8d6aa0ef-6d6e-43eb-b4ce-a38d18a119e9)(content(Whitespace\" \ + \"))))(Tile((id \ + 1b47f773-650a-49bd-85cb-caa2a182fa26)(label(0))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort \ - Exp))))))(shards(0))(children())))))))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Secondary((id \ - 2070e7f5-1a9b-4ed3-8b42-a9e548ff82a0)(content(Whitespace\" \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 4a74b81f-443b-4c0e-98d2-f8927bef69ad)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 9177e4f8-11bd-4171-9fb8-5eeaedeab3e5)(content(Whitespace\"\\n\"))))(Tile((id \ - ec5304e8-dd1a-4bcc-ad61-fb1fe0ee6ad0)(label(let = \ + 8fe10968-2399-49d8-89b9-aa636b3d729b)(content(Whitespace\"\\n\"))))(Tile((id \ + aaa68576-1ac7-421b-8c5a-2b77e1a8d1d1)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ 2))(children(((Secondary((id \ - bdb859a4-36c0-4841-937f-80223fa98c24)(content(Whitespace\" \ + 9e7c06e7-99e4-4722-a568-89d4a1922cb5)(content(Whitespace\" \ \"))))(Tile((id \ - 800a1e29-08f0-47df-a1dc-dced3ad9d526)(label(fourth))(mold((out \ + 2bc4d667-ae8c-4f8e-9e24-7d9199cec322)(label(_))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - 1e0d0659-d19c-4dab-ad19-ab01fce29b59)(content(Whitespace\" \ + 41c413d8-eeee-4631-bf27-c966cd63facf)(content(Whitespace\" \ \")))))((Secondary((id \ - 8f5efc45-a2ee-442d-a27a-9aff78c17c44)(content(Whitespace\" \ + 662d5a91-dfec-467f-8e8e-f6d45e51569a)(content(Whitespace\" \ + \"))))(Secondary((id \ + d59997e1-66bb-4fd0-b70b-11381ae85982)(content(Whitespace\" \ \"))))(Tile((id \ - cb83a2ea-3b39-4f7e-806c-c9e1b58d54ab)(label(fun \ - ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 7dbe8403-114f-4684-a156-da6588b7295c)(label(case \ + end))(mold((out Exp)(in_(Rul))(nibs(((shape Convex)(sort \ + Exp))((shape Convex)(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - 99a0006d-d489-415d-b217-3237cbeb0ea3)(content(Whitespace\" \ + 80b1807b-461d-41b5-99cd-eec6bda0e92d)(content(Whitespace\" \ \"))))(Projector((id \ - b9ee5f14-1489-446d-9170-864b5ba41490)(kind \ + c2e07164-aabd-43d1-865c-34c8a9affff0)(kind \ Probe)(syntax(Tile((id \ - b9ee5f14-1489-446d-9170-864b5ba41490)(label(x))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + c2e07164-aabd-43d1-865c-34c8a9affff0)(label(maybe))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ - Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - 1fe23d69-172b-408a-a433-da8557e80151)(content(Whitespace\" \ + 0d6706dd-66de-4d50-a437-bf33a4c3d40b)(content(Whitespace\"\\n\"))))(Tile((id \ + ce52bb5d-d9dd-47de-a97b-00dc28d387c9)(label(| =>))(mold((out \ + Rul)(in_(Pat))(nibs(((shape(Concave 41))(sort \ + Exp))((shape(Concave 41))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + c66c1715-d463-46ff-b542-91bc0c251b4c)(content(Whitespace\" \ + \"))))(Tile((id \ + bfb82f8b-5e99-4ca0-9e6c-050ec5d355d2)(label(21))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + be884491-0605-4868-8f40-96e8d76129e5)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 14a44874-e543-44f0-b64a-2cf342521e91)(content(Whitespace\" \ - \"))))(Secondary((id \ - 1c57c185-c919-4119-81eb-8d4e9329d5b0)(content(Whitespace\"\\n\"))))(Projector((id \ - a1409f64-ad04-43d6-b70f-81950fcb8192)(kind \ + 858d5896-0b1b-4ba3-8235-b281fa3eff7e)(content(Whitespace\" \ + \"))))(Projector((id \ + be6dc0e3-9415-495b-beb0-fe68776d87ac)(kind \ Probe)(syntax(Tile((id \ - a1409f64-ad04-43d6-b70f-81950fcb8192)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - f54e03db-1c6b-477c-bd87-db346253f867)(label(fifth))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 2352a91d-2891-455f-a665-cd04ad2beba7)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - a8f0b746-d00d-4b15-bf23-d6f7dce50904)(label(x))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - fcb490c3-c1b0-48b7-a56b-da0ec0b2c0a9)(content(Whitespace\" \ - \"))))(Tile((id \ - 3e4f9c0b-6e0c-4999-9ad0-61ca6398ab50)(label(-))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 27))(sort \ - Exp))((shape(Concave 27))(sort \ - Exp))))))(shards(0))(children())))(Secondary((id \ - 4a923ca0-5ff4-48f0-bd4f-064fef34a58d)(content(Whitespace\" \ - \"))))(Tile((id \ - c6860869-f0e6-43eb-a301-30c4f455fbdd)(label(4))(mold((out \ + be6dc0e3-9415-495b-beb0-fe68776d87ac)(label(\"\\\"necessary\\\"\"))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ - Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - acba5cba-989d-4ede-9bca-37ce99541468)(content(Whitespace\" \ - \"))))(Tile((id \ - 0b2c1381-b8ab-4f0b-9b80-8c77227082ad)(label(+))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 27))(sort \ - Exp))((shape(Concave 27))(sort \ - Exp))))))(shards(0))(children())))(Secondary((id \ - 64a4c16c-6ac1-4d95-ad0e-21858f196f23)(content(Whitespace\" \ + f851d05b-5187-467f-87b8-94a2708d4568)(content(Whitespace\"\\n\"))))(Tile((id \ + ef7b6bfd-dd58-4bb2-8d87-07c21364dc5f)(label(| =>))(mold((out \ + Rul)(in_(Pat))(nibs(((shape(Concave 41))(sort \ + Exp))((shape(Concave 41))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + bc56424a-f3b3-40f6-9ed2-0846a5849900)(content(Whitespace\" \ \"))))(Tile((id \ - 540ad80c-634c-49c3-b409-1941592ae887)(label(1))(mold((out \ + 2e1d3623-98c6-4d9c-9522-8aa57286a3c9)(label(_))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 0cf69421-c132-4a6c-a1e4-513b7daf4686)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 2892df8d-c180-4229-8b2c-8eb21c5f984d)(content(Whitespace\" \ + \"))))(Projector((id \ + 6f59a915-1a20-4087-8438-505024ce8885)(kind \ + Probe)(syntax(Tile((id \ + 6f59a915-1a20-4087-8438-505024ce8885)(label(\"\\\"impossible\\\"\"))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - 46521b0c-8a69-4b06-a2b8-667e9bcc7a90)(content(Whitespace\" \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 7a479696-fad2-4358-81ae-139eafdd97d5)(content(Whitespace\"\\n\")))))))))(Secondary((id \ + 45314477-f3e7-4121-ab8c-8f3c3498de67)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 3442b621-9409-4458-b880-fd24ada82816)(content(Whitespace\"\\n\"))))(Tile((id \ - d35bfabb-d398-4b18-a150-f351d931159e)(label(let = \ + 0e6bf9c6-5ce8-44c8-94c3-78096f46b6ec)(content(Whitespace\"\\n\"))))(Secondary((id \ + efec0a05-7486-4240-b07f-6d94fa792fcf)(content(Comment\"# Note \ + the 2nd branch probe has a zero to the right. \ + #\"))))(Secondary((id \ + 6d7955af-41e4-4725-b7a0-39009a6fe44d)(content(Whitespace\"\\n\"))))(Secondary((id \ + a5a31326-522d-4c04-bd62-e656c3d3d69b)(content(Comment\"# This \ + is the cell's collected closure count, i.e. \ + #\"))))(Secondary((id \ + aa2c7356-aa30-48f9-b72a-d7584f09ce8e)(content(Whitespace\"\\n\"))))(Secondary((id \ + 0358cc96-f900-4486-9b3c-5e333ec50be7)(content(Comment\"# the \ + number of times the expression was evaluated \ + #\"))))(Secondary((id \ + 6039b3ef-8006-4d48-a892-d5e21f2e606b)(content(Whitespace\"\\n\"))))(Secondary((id \ + 754e1f3f-c839-4378-a213-64ca6795927a)(content(Whitespace\"\\n\"))))(Secondary((id \ + 2960bafc-8080-427b-9421-640fd96979b3)(content(Comment\"# \ + Probes can be placed on expressions: #\"))))(Secondary((id \ + 4708993e-454f-4d92-8c7e-1aab35d445ad)(content(Whitespace\"\\n\"))))(Tile((id \ + d73c2733-1a36-44d5-8bc1-7bf7d886e681)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ 2))(children(((Secondary((id \ - 102fe5a8-c680-4a8d-8709-811d71142cff)(content(Whitespace\" \ + fa333a91-c114-463d-b656-f40f4b242470)(content(Whitespace\" \ \"))))(Tile((id \ - f130e49d-aba3-43bd-8346-fec8c01c6fc5)(label(third))(mold((out \ + aecac108-3ae8-4b8b-87d4-aa71b62add35)(label(story))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - f35cba72-07c5-4bd9-afbb-f0d2b22a2e65)(content(Whitespace\" \ + c4b160c8-81a1-4071-a5df-5ab0270e3025)(content(Whitespace\" \ \")))))((Secondary((id \ - fe151c0c-ce3d-4bc9-9227-97e51a0aa3ac)(content(Whitespace\" \ - \"))))(Tile((id \ - 301abc18-7d85-4c67-b19a-152cf8dcd25b)(label(fun \ - ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ - 1))(children(((Secondary((id \ - b88a1c5f-dcd1-4974-93c9-826b1fa88d7d)(content(Whitespace\" \ + c6a863ec-9669-4001-8ddd-e1cbbeffecc3)(content(Whitespace\" \ \"))))(Projector((id \ - a60622e3-bbe2-4d29-9081-97e4dc53e45b)(kind \ + ab24c8a6-37c6-4044-aacc-a820db6304d8)(kind \ Probe)(syntax(Tile((id \ - a60622e3-bbe2-4d29-9081-97e4dc53e45b)(label(x))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort \ - Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Secondary((id \ - 921b48b9-f216-448b-be7a-5bee37cc4af8)(content(Whitespace\" \ - \")))))))))(Secondary((id \ - 45d7b101-b573-4aa9-9e2d-808f46c1472e)(content(Whitespace\" \ - \"))))(Secondary((id \ - 9c790c99-85f5-4161-a335-96a8cc16cd3a)(content(Whitespace\"\\n\"))))(Projector((id \ - efdbda6c-ad4a-45b0-9f7e-997608ce3f94)(kind \ - Probe)(syntax(Tile((id \ - efdbda6c-ad4a-45b0-9f7e-997608ce3f94)(label(\"(\"\")\"))(mold((out \ + ab24c8a6-37c6-4044-aacc-a820db6304d8)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - eb2ee1dc-1e4f-4613-92ff-7f3cd4a375dd)(label(fourth))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - fd9d5a3d-f0db-4d78-88da-c93cf444c040)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - a0d526c3-d5c5-4984-aed6-738444ac99d5)(label(x))(mold((out \ + Convex)(sort Exp))))))(shards(0 1))(children(((Projector((id \ + af2a1593-c5e3-42b5-ab50-e19f15b0e863)(kind \ + Slider)(syntax(Tile((id \ + af2a1593-c5e3-42b5-ab50-e19f15b0e863)(label(50))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ - Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Secondary((id \ - 175e08db-4d46-404b-82ee-ab6004481f6f)(content(Whitespace\" \ + Exp))))))(shards(0))(children()))))(model\"()\")))(Secondary((id \ + 872e00f6-d272-4c6b-a3d7-c0e53a8ad50a)(content(Whitespace\" \ \"))))(Tile((id \ - 6a0532d0-defa-41dd-9552-575ac03f5370)(label(/))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 26))(sort \ - Exp))((shape(Concave 26))(sort \ + 38ee9261-c31d-4c43-af84-78bdd13ba362)(label(**))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 25))(sort \ + Exp))((shape(Concave 25))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 69475242-7ac8-480b-b574-81086004e703)(content(Whitespace\" \ + 4121ad36-3062-4100-976b-0652ab387011)(content(Whitespace\" \ \"))))(Tile((id \ - a8553361-f5a6-407c-a6b0-4c8f1737e6d0)(label(4))(mold((out \ + 029f5e79-b90b-45cb-8589-1f74286a2272)(label(2))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - 8d87988d-bd62-4b44-b5d9-74e41f5ab98c)(content(Whitespace\" \ + Convex)(sort \ + Exp))))))(shards(0))(children())))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 71768352-ef14-471a-b0dc-c33b32245f04)(content(Whitespace\" \ \")))))))))(Secondary((id \ - ae8940e9-18ac-4881-8bcc-287818dbe598)(content(Whitespace\"\\n\"))))(Tile((id \ - d1ba74d0-8ed3-4a30-bacf-45bf2b2ef9d2)(label(let = \ + ff7c4dab-6c65-46fa-81fe-14540fa2c51c)(content(Whitespace\"\\n\"))))(Secondary((id \ + 9eebf709-32ca-465f-808d-d81975bfedfc)(content(Comment\"# And \ + also on patterns (e.g. variables), shown in blue: \ + #\"))))(Secondary((id \ + 08304d98-477a-4024-9896-e16b6922c1fc)(content(Whitespace\"\\n\"))))(Tile((id \ + 7c42b54b-2678-4702-b412-5427c5e9dc25)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ 2))(children(((Secondary((id \ - b7363479-109c-4cc8-b3be-81537f303114)(content(Whitespace\" \ - \"))))(Tile((id \ - c42b27f9-8833-4e4c-b0f0-266381abeeab)(label(second))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - 1ec1a828-bcf9-4534-8e30-4f127d2e4138)(content(Whitespace\" \ - \")))))((Secondary((id \ - e9031146-cf7f-4ddf-9a10-9c631c8f5621)(content(Whitespace\" \ - \"))))(Tile((id \ - c6685701-3932-4485-a9ee-23efed57c09b)(label(fun \ - ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ - 1))(children(((Secondary((id \ - 300d8def-9265-44f8-a3da-d622a8238fba)(content(Whitespace\" \ + ce42e047-dda8-4e3a-92e3-28a7f0f42010)(content(Whitespace\" \ \"))))(Projector((id \ - c0467909-6f41-4aa2-8722-a5c5aa5be074)(kind \ + 846ed995-2357-4a56-9f44-00519baf0e1d)(kind \ Probe)(syntax(Tile((id \ - c0467909-6f41-4aa2-8722-a5c5aa5be074)(label(x))(mold((out \ + 846ed995-2357-4a56-9f44-00519baf0e1d)(label(story))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort \ - Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Secondary((id \ - 2ee1be25-dfef-4425-a25a-562425ba13c8)(content(Whitespace\" \ - \")))))))))(Secondary((id \ - 88a68b74-e6ac-4044-868f-639dc3e2551e)(content(Whitespace\" \ - \"))))(Secondary((id \ - ff092233-29e9-4a75-864b-6b1e1373262c)(content(Whitespace\"\\n\"))))(Projector((id \ - d8b80f6d-ca66-4f59-924d-f21193b089fa)(kind \ - Probe)(syntax(Tile((id \ - d8b80f6d-ca66-4f59-924d-f21193b089fa)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 83ff51e6-1fd8-4572-bb31-cc75ddd19674)(label(third))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 6890df9e-1759-4b95-90b2-c4314ff0b6df)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - f32f8e0a-1a4f-4cc2-bfe4-1e1873987429)(label(3))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - 56670704-b1d7-49f1-b64a-ab605ca488f5)(content(Whitespace\" \ - \"))))(Tile((id \ - 47cbfa2a-dd14-426c-aaa5-8df036fef201)(label(*))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 26))(sort \ - Exp))((shape(Concave 26))(sort \ - Exp))))))(shards(0))(children())))(Secondary((id \ - 0e9b96d2-a5d3-4b48-b607-191952c18f2b)(content(Whitespace\" \ - \"))))(Tile((id \ - 87e818fe-7ef3-41f2-b80c-68ec3c721004)(label(x))(mold((out \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths((017c60cf-3484-46f2-a06a-2b1514140f72 \ + 19)))(max_closures 30)(index_offset 0))\")))(Secondary((id \ + 8fb2b8f8-8f3d-48f4-a162-ca5d17735c0d)(content(Whitespace\" \ + \")))))((Secondary((id \ + ca238785-23de-4930-b270-2fd5cb4730a5)(content(Whitespace\" \ + \"))))(Projector((id \ + 6c9f6679-d04a-4b88-a8f5-d3c78d13f28a)(kind \ + Slider)(syntax(Tile((id \ + 6c9f6679-d04a-4b88-a8f5-d3c78d13f28a)(label(50))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ - Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Secondary((id \ - 5837d481-a939-4ef0-97fb-3fcdc94bb684)(content(Whitespace\" \ + Exp))))))(shards(0))(children()))))(model\"()\")))(Secondary((id \ + d6a7cd97-d986-4e6f-bf5a-0d4786df29fc)(content(Whitespace\" \ \"))))(Tile((id \ - a6360712-cd42-40d9-b77c-da44be856ef5)(label(+))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 27))(sort \ - Exp))((shape(Concave 27))(sort \ + 32688aa2-5a9f-4c99-baee-30f5438b3106)(label(**))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 25))(sort \ + Exp))((shape(Concave 25))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 1d1878cc-be40-4c1e-9093-9526004b14c2)(content(Whitespace\" \ + 762e8c4c-469d-4959-bb9f-9512c02d7781)(content(Whitespace\" \ \"))))(Tile((id \ - 97b5e533-2669-4588-bada-2c62373f45fa)(label(1))(mold((out \ + 90a1e850-bee7-4bc0-ad43-e2d7276986bd)(label(2))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - e2b7dbca-a7b3-4774-abf0-59295bf517b0)(content(Whitespace\" \ + bcd11834-3c5d-40ab-9adf-1a7c3d434ef5)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 8c5f4629-286a-4837-836b-6a3eca6e848a)(content(Whitespace\"\\n\"))))(Tile((id \ - 5ff3f001-e57c-457b-a793-e1ac39f36b01)(label(let = \ + b35b8c4a-850a-468d-8695-d3b623147a35)(content(Whitespace\"\\n\"))))(Secondary((id \ + 7a979aec-b75b-41a0-85dd-068a454c5d85)(content(Comment\"# \ + Expressions currently CAN'T BE EDITED WHILE PROBED \ + #\"))))(Secondary((id \ + dcbe770e-e4d8-442a-bf4b-52bbf72047c3)(content(Whitespace\"\\n\"))))(Secondary((id \ + d77998e8-6313-4dfd-a5b3-7de7f1c62ac5)(content(Comment\"# So \ + probing a name instead makes iteration easier. \ + #\"))))(Secondary((id \ + 440973cc-3081-4e4d-8daa-357613d1e75b)(content(Whitespace\"\\n\"))))(Secondary((id \ + a820a36e-4f51-40a2-9ee0-d9c3c738ae98)(content(Whitespace\"\\n\"))))(Secondary((id \ + 84c8656b-4a11-4bdb-8050-b380883a7220)(content(Whitespace\"\\n\"))))(Secondary((id \ + e8e87b6b-7bb7-4bb0-8468-57912a7c410a)(content(Comment\"# \ + FUNCTIONS #\"))))(Secondary((id \ + 6838679b-5e10-44c9-ab60-9dd865e2a4a4)(content(Whitespace\"\\n\"))))(Tile((id \ + c644c9b0-d167-4874-9563-21f3f1595adf)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ 2))(children(((Secondary((id \ - fd4070e2-cd56-4900-a487-32d201315e17)(content(Whitespace\" \ + c7837266-1cf5-4356-9f8b-c905dbd314af)(content(Whitespace\" \ \"))))(Tile((id \ - ec9e7c80-bc99-4071-a462-436549d0e797)(label(first))(mold((out \ + 8445685c-ebe2-4502-990a-2ffc1c8f7f00)(label(_))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - 8023e887-ef1e-46a1-be1b-f24ffb83c519)(content(Whitespace\" \ + f83b5579-4e89-4e61-b72b-c90247d0c919)(content(Whitespace\" \ \")))))((Secondary((id \ - e525abca-5049-45c8-aec4-4eee6e812953)(content(Whitespace\" \ + a7314c28-387e-46df-9622-dfa0cc2e5ed5)(content(Whitespace\"\\n\"))))(Secondary((id \ + 3ac998c3-4bc0-4288-83ba-507684856415)(content(Comment\"# \ + Because functions can run multiple times, they can \ + #\"))))(Secondary((id \ + 6f7e53a4-865c-424b-a85f-925018674a1d)(content(Whitespace\"\\n\"))))(Secondary((id \ + 4ba86ce5-1448-4492-9824-b9a6e65abbc5)(content(Comment\"# have \ + multiple cells. Note the closure counts below \ + #\"))))(Secondary((id \ + 5e3266ee-0048-477e-9458-a206cf8f798e)(content(Whitespace\"\\n\"))))(Secondary((id \ + 6d4c4c5c-c581-4eb2-a5ff-4a80d8d9fa61)(content(Comment\"# are \ + all 2, indicating each probe was evaluated twice. \ + #\"))))(Secondary((id \ + 0422c753-8ed4-4b41-98e7-4b3b7bfeb83f)(content(Whitespace\"\\n\"))))(Tile((id \ + 8a4f80e8-6138-4850-b9ae-2784df4fe0e1)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 0cf9522a-f0a4-4735-8708-b9c4f3fc2965)(content(Whitespace\" \ \"))))(Tile((id \ - 4add151a-e3b1-4e04-8dd7-b58328e4f040)(label(fun \ + 7f231d91-d0c0-45ff-8555-99314a3fe5e9)(label(celcius))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 4b12e5a8-60aa-4033-aac4-b1926ade5ba1)(content(Whitespace\" \ + \")))))((Secondary((id \ + f65fe921-ce9d-44e2-bdd9-61acc26eabdd)(content(Whitespace\" \ + \"))))(Tile((id \ + 007c1e57-3a4a-474a-b9c8-7df827ffe576)(label(fun \ ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - 04772292-fdc8-4b40-9a22-7138c6c9c065)(content(Whitespace\" \ + 8d6e7f34-2f9b-472b-a202-e51b601471ab)(content(Whitespace\" \ \"))))(Projector((id \ - 2377ec38-ac4f-4180-a208-7037db7754bc)(kind \ + 2a016e4b-98a0-445f-b208-15e00fc0d5ec)(kind \ Probe)(syntax(Tile((id \ - 2377ec38-ac4f-4180-a208-7037db7754bc)(label(x))(mold((out \ + 2a016e4b-98a0-445f-b208-15e00fc0d5ec)(label(farenheit))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort \ Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - 30f629a3-ac23-4406-aada-20e87638273b)(content(Whitespace\" \ + 4c9c416d-bd83-46b3-b256-5e8b2d7605e9)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 0f2deaeb-c710-4493-9e0e-b02f0933e5df)(content(Whitespace\" \ - \"))))(Secondary((id \ - 97b6f168-1755-4955-8ed9-67b282cb7967)(content(Whitespace\"\\n\"))))(Projector((id \ - 355ea9a0-0dcb-489f-8b65-a186ff68f6c8)(kind \ + 1e26169d-dd12-4401-ae29-e2d1ab9bf030)(content(Whitespace\"\\n\"))))(Secondary((id \ + b5607be9-a027-4ca4-894a-adf34e2faf2c)(content(Comment\"# \ + Click to select the cell above reading 72.5 \ + #\"))))(Secondary((id \ + a22d958f-5a55-4873-94df-c97fa1db1873)(content(Whitespace\"\\n\"))))(Tile((id \ + 34affb5e-80bd-4b01-bcc6-9ec5349296e1)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 22ac8742-fd19-44af-838f-bd2a6e6422ac)(content(Whitespace\" \ + \"))))(Projector((id \ + fea0443b-485b-4680-a352-2096f979b0a3)(kind \ Probe)(syntax(Tile((id \ - 355ea9a0-0dcb-489f-8b65-a186ff68f6c8)(label(\"(\"\")\"))(mold((out \ + fea0443b-485b-4680-a352-2096f979b0a3)(label(diff))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 3b737ed5-6d09-4f11-8801-3d97849cd8c7)(content(Whitespace\" \ + \")))))((Secondary((id \ + aa100a1d-ba9e-4c29-9fab-3e6625307fb9)(content(Whitespace\" \ + \"))))(Tile((id \ + c808dc6e-b377-4384-b64c-987ec3ec0fed)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 1b1adb02-c753-4c41-84f2-c0d7b1b7092e)(label(second))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 0a342842-94a0-48f8-b822-503599390f4a)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 76dc0878-125d-4bdc-abc3-e044ef2db8eb)(label(x))(mold((out \ + f35d3359-2fe8-4b99-ad20-77f0db145062)(label(farenheit))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - c0b40bd6-9bea-4bc8-a2aa-e581d586600d)(content(Whitespace\" \ + 1278a5d4-964c-49ad-95f5-bea6f577f321)(content(Whitespace\" \ \"))))(Tile((id \ - 6afef7d4-2740-4462-a6bc-9861dcab73ff)(label(+))(mold((out \ + 3981a456-f875-4b9b-8c2b-08f0c2e8612c)(label(-.))(mold((out \ Exp)(in_())(nibs(((shape(Concave 27))(sort \ Exp))((shape(Concave 27))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - b007c652-05d4-4102-9319-da7f135fcea3)(content(Whitespace\" \ + 82c43d73-0b86-4169-a027-cead0a4d8c41)(content(Whitespace\" \ \"))))(Tile((id \ - ced6e1bf-64ac-4479-8eb0-b53abf9f112c)(label(2))(mold((out \ + 882ba1dc-8006-48a0-b9db-45917e30a009)(label(32.))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ - Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Secondary((id \ - 98d68578-38c2-4791-a68f-14195d9e9ba9)(content(Whitespace\" \ + Exp))))))(shards(0))(children()))))))))(Secondary((id \ + 79bbcca5-0718-4e57-a41b-258b07bb042c)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 4b623ff7-80a4-4726-9c25-5ceae0c7cf91)(content(Whitespace\"\\n\"))))(Secondary((id \ + 9c9befce-21bf-46c6-b609-973ef7954869)(content(Comment\"# This \ + highlights cells below corresponding to the same \ + #\"))))(Secondary((id \ + 5e3e3ee8-828b-4380-8c77-66ce9886e6ba)(content(Whitespace\"\\n\"))))(Secondary((id \ + e7632290-d8ac-46cb-90e3-07b8b1a74709)(content(Comment\"# \ + function call: the cells reading 40.5 and 22.5) \ + #\"))))(Secondary((id \ + d240c049-a28d-4712-936f-bc9a4243af2e)(content(Whitespace\"\\n\"))))(Projector((id \ + e748427c-ea98-481a-8e5a-5b1fbf332c91)(kind \ + Probe)(syntax(Tile((id \ + e748427c-ea98-481a-8e5a-5b1fbf332c91)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + b7e607fc-eea3-411a-afa1-0b10f79e685b)(label(5.))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 9b6f1478-2cc5-4c2b-9fad-05864c16a2ec)(label(/.))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ + Exp))))))(shards(0))(children())))(Tile((id \ + 4b7be7d7-c7d0-43ff-91b7-516b3dadbb00)(label(9.))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 916af026-a1b2-4950-940b-c5327561d8f4)(content(Whitespace\" \ \"))))(Tile((id \ - 365455db-c825-4700-b86a-4aa0695cd7d3)(label(*))(mold((out \ + e5558659-6260-4431-bbca-5d882f8e298a)(label(*.))(mold((out \ Exp)(in_())(nibs(((shape(Concave 26))(sort \ Exp))((shape(Concave 26))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 87263b4a-bba0-495a-9b1e-f066feddc0c4)(content(Whitespace\" \ + ce76a9b3-f576-4bcc-8ce2-1cba962ae76d)(content(Whitespace\" \ \"))))(Tile((id \ - d91c14a5-9ca9-4cf3-8285-6410365e0114)(label(2))(mold((out \ + 24de60c3-7aec-42cc-bc89-bb069932e7dc)(label(diff))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - ca96f4e7-fc99-4654-8cd6-52493c01ae4a)(content(Whitespace\" \ + Convex)(sort \ + Exp))))))(shards(0))(children())))))))))(model\"((display_lengths((09ca2848-629b-4445-b671-ead905cb7731 \ + 6)(6f622f65-620e-402f-a5c2-432aab5c354b 7)))(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + a8173c79-0b37-4f23-8e70-21194638057e)(content(Whitespace\" \ \")))))))))(Secondary((id \ - b4442ac4-cbb9-44f5-9911-7f77a9cdfd7d)(content(Whitespace\"\\n\"))))(Tile((id \ - 3a7161f4-b180-46e6-afa1-b2b60ec23592)(label(let = \ + d01c5efd-306e-4cfb-a965-ee78e2ae4f9b)(content(Whitespace\"\\n\"))))(Tile((id \ + e8feab30-b778-40a0-a22c-709c6b5385d8)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ 2))(children(((Secondary((id \ - 9b10dc8c-4963-43bf-a853-0d58f9f75ca7)(content(Whitespace\" \ + fa1025f3-5c24-412b-825d-c98f01bed0fe)(content(Whitespace\" \ \"))))(Tile((id \ - 990196e5-4434-4a4f-81d2-cca3fc8991fe)(label(_))(mold((out \ + 9099e47d-6200-4421-bdf8-49ed12871ce5)(label(\"(\"\")\"))(mold((out \ + Pat)(in_(Pat))(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0 1))(children(((Tile((id \ + c3db17cc-fb7a-45a9-9a79-efe55ba03702)(label(t1))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - bf0b2396-b28a-42e1-969f-78149123646b)(content(Whitespace\" \ + Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ + 740871a0-f3e8-4592-92ea-ffeb16f0d8be)(label(,))(mold((out \ + Pat)(in_())(nibs(((shape(Concave 45))(sort \ + Pat))((shape(Concave 45))(sort \ + Pat))))))(shards(0))(children())))(Secondary((id \ + 1fddedcb-7ee6-4cce-851a-9f6f64c02028)(content(Whitespace\" \ + \"))))(Tile((id \ + 8d2a8ef4-78f8-4050-8dd1-e2b5dad870f6)(label(t2))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))))))(Secondary((id \ + bcb9efed-64e6-40fa-8331-e1641186c7cb)(content(Whitespace\" \ \")))))((Secondary((id \ - 54ab0af8-d856-45de-9c20-6458245f75da)(content(Whitespace\" \ - \"))))(Projector((id \ - cd624e97-f51d-4310-b622-6eae20023b8b)(kind \ - Probe)(syntax(Tile((id \ - cd624e97-f51d-4310-b622-6eae20023b8b)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - e98de5e1-368d-4c62-87e2-70dc67bb07f6)(label(first))(mold((out \ + 9e1beb73-b34b-457d-b0c9-5e4014f0d026)(content(Whitespace\" \ + \"))))(Tile((id \ + 0ab0a674-887f-4e0e-a6d6-095a799c5188)(label(72.5))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - cebdb748-72e4-4d22-b5b7-dfdf2115bd5d)(label(\"(\"\")\"))(mold((out \ + 92df64d7-4ee5-4b2d-8494-6b7297b1352b)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 45))(sort \ + Exp))((shape(Concave 45))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 1d81e836-5052-43e3-b3df-e365f0d90c55)(content(Whitespace\" \ + \"))))(Tile((id \ + b3e242ef-7935-48f5-8466-1242c0a134d5)(label(103.1))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 9fedd895-554a-4d2a-a389-1f3e528a673b)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 3726f6c1-a848-4c3c-89c6-d6c0451076aa)(content(Whitespace\" \ + \"))))(Tile((id \ + 8e8b2ff0-8ec1-4cd9-bd64-2e2741b9b3af)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Secondary((id \ + a81d8964-7a0c-4936-9a98-388828530bd6)(content(Whitespace\"\\n\"))))(Secondary((id \ + 2a334b61-7c34-40a5-98a4-f9e8811f3134)(content(Comment\"# It \ + also highlights in purple the cell #\"))))(Secondary((id \ + cac19712-6bd8-46ca-b205-97a8955c2f76)(content(Whitespace\"\\n\"))))(Secondary((id \ + 484cce16-95ee-4b26-b3bc-a4067680a97d)(content(Comment\"# of \ + the function's call site#\"))))(Secondary((id \ + 54028b97-1919-405a-b932-b674dda7e596)(content(Whitespace\"\\n\"))))(Projector((id \ + d0a64e39-1183-4878-9b4d-ddeb25585a2f)(kind \ + Probe)(syntax(Tile((id \ + d0a64e39-1183-4878-9b4d-ddeb25585a2f)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + b280ccb9-0a8b-48a3-9741-ec8be29ce423)(label(celcius))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 87519f3e-32a5-4986-a518-b81d71374000)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - fb1c8aaf-7386-470e-a9f0-1c11697d676e)(label(5))(mold((out \ + 64fdfb6d-4349-4c40-a0d6-497bdbad2074)(label(t1))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Tile((id \ + e3552276-5dc1-4a26-9439-9c98a1440fb8)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 45))(sort \ + Exp))((shape(Concave 45))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 7b5e5c50-067a-4e6a-b2e3-67ff157ee7d5)(content(Whitespace\"\\n\"))))(Secondary((id \ + c811b5f6-6202-47ee-8557-580653540b57)(content(Comment\"# Now \ + select the cell above reading 22.5 #\"))))(Secondary((id \ + cc332168-3240-4b03-b752-3dc3e66f7246)(content(Whitespace\"\\n\"))))(Projector((id \ + 694c2624-7283-493b-9104-37afcf3f576e)(kind \ + Probe)(syntax(Tile((id \ + 694c2624-7283-493b-9104-37afcf3f576e)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 7ed47029-3323-4f9e-8ef1-b4b8e02abf3f)(label(celcius))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 8f84a947-ec49-43f2-ac86-89fd1990ced4)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + eb2adc9d-b90d-4b81-8ed6-10d66f2b63be)(label(t2))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - 5a49e6ff-bb58-49bd-93c9-4d1347d2f44e)(content(Whitespace\" \ + 873d7588-4fb9-489f-8be4-e299149e9d37)(content(Whitespace\"\\n\"))))(Secondary((id \ + 2d146356-7808-48da-a4c4-e681cbc30f15)(content(Comment\"# Note \ + the 103.1, 71.1, and 39.5 are no longer green-highlit \ + #\"))))(Secondary((id \ + 32bb59ab-bc35-4237-93c7-17ff41ec3e0e)(content(Whitespace\"\\n\"))))(Secondary((id \ + d2b1800a-ed37-4b4a-bee0-c6db2da7019b)(content(Comment\"# as \ + they are not part of the same call as /the expression/ \ + #\"))))(Secondary((id \ + d480e309-bd5d-4ee3-82b1-e9aedf5ce97b)(content(Whitespace\"\\n\"))))(Secondary((id \ + c96bfa9d-4ac4-4e9b-bb1a-2aaa3b1acb2a)(content(Comment\"# \ + `celcius(t1)`. However, they are now outlined in purple, as \ + #\"))))(Secondary((id \ + 12f76d6b-12e7-444d-9763-bbea991c9dab)(content(Whitespace\"\\n\"))))(Secondary((id \ + ecfbf453-7544-40d9-929c-545ab0334a82)(content(Comment\"# they \ + are contained in the callstack created by that call \ + #\"))))(Secondary((id \ + 7456b7e5-854f-4889-904c-f0c13c9eb040)(content(Whitespace\"\\n\")))))))))(Secondary((id \ + 979ab033-2251-4659-86aa-eaea979c9499)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 75e108ca-3987-4705-b0ff-fd98eac3832d)(content(Whitespace\"\\n\"))))(Secondary((id \ - 10fdb2c6-6379-4f77-9411-feed6e730480)(content(Whitespace\"\\n\"))))(Secondary((id \ - 38f12425-72f2-4afc-9e8f-cf29ea159f7d)(content(Comment\"# \ - functions in functions #\"))))(Secondary((id \ - 8f0d3403-e3c7-410d-8054-cfccef303571)(content(Whitespace\"\\n\"))))(Tile((id \ - 5c8317fe-71eb-4888-921f-282519872b93)(label(let = \ + a080d60a-ccab-48c2-bdfd-22a4444a140f)(content(Whitespace\"\\n\"))))(Secondary((id \ + e662152b-c2a7-4c1b-9d0d-2a26a3cd27fe)(content(Whitespace\"\\n\"))))(Secondary((id \ + d046139b-ab4f-43e6-90d0-5bdfe3fc8091)(content(Whitespace\"\\n\"))))(Secondary((id \ + 1a6e74ac-ae49-4831-80b9-bc58e1c9785f)(content(Comment\"# \ + FUNCTIONS CALLING FUNCTIONS #\"))))(Secondary((id \ + 2c5deea0-6860-4ae6-8baa-62791e7a2e89)(content(Whitespace\"\\n\"))))(Tile((id \ + 3a7161f4-b180-46e6-afa1-b2b60ec23592)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ 2))(children(((Secondary((id \ - 9c6914fd-ee0f-4dc7-8547-c6ea8e0c94fd)(content(Whitespace\" \ + 28dc3bdb-ec81-42ce-a47c-2ed8273964e3)(content(Whitespace\" \ \"))))(Tile((id \ - fbbfeb41-2a75-4052-bbc4-2d65ad38e586)(label(outer))(mold((out \ + e35ff13e-f5e0-4c06-8d44-b96090245b93)(label(_))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - 1e8f222d-5f65-4827-b8f4-b96314a20ba7)(content(Whitespace\" \ + c98ac483-d6bf-40fb-ad58-4927e83a325c)(content(Whitespace\" \ \")))))((Secondary((id \ - 5e1f2383-2e52-4fa1-994e-cfbe666a4dd5)(content(Whitespace\" \ + f2f0c0de-b1ce-40ee-8ea4-f9a3d40b13c2)(content(Whitespace\"\\n\"))))(Tile((id \ + a137c9ef-2d61-4ee9-bb17-d9dda9b2a847)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 1acce041-c1d4-4f4b-b18f-62977e8355fb)(content(Whitespace\" \ \"))))(Tile((id \ - c5dfe928-5571-47e5-81d3-f33d1b76f7bb)(label(fun \ + 319eed34-9c43-4ada-84a2-07f132cf9050)(label(fourth))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + a9835df3-b589-47a8-8444-e59b3aa93f90)(content(Whitespace\" \ + \")))))((Secondary((id \ + ce3bf749-cf23-4fd7-ac92-0afac717100a)(content(Whitespace\" \ + \"))))(Tile((id \ + ef90a214-bb3f-46e7-ac4f-8189a8b0c912)(label(fun \ ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - 844a4e06-48a0-4d06-98f0-643f53638da7)(content(Whitespace\" \ + 4798d1b8-a19d-4827-aeb7-021c229b5692)(content(Whitespace\" \ \"))))(Projector((id \ - 65038c37-8676-4e5f-8503-ada7771f4bd1)(kind \ + e5ac31d7-515d-4f42-babd-c7e592b97b02)(kind \ Probe)(syntax(Tile((id \ - 65038c37-8676-4e5f-8503-ada7771f4bd1)(label(y))(mold((out \ + e5ac31d7-515d-4f42-babd-c7e592b97b02)(label(f))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort \ Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - f9b9146e-9253-4cdd-8610-14c83013ac34)(content(Whitespace\" \ + ec63e8ad-0fdd-45bd-8e49-0005240ef297)(content(Whitespace\" \ \")))))))))(Secondary((id \ - bc350b60-c66e-483c-9d84-c668d3d2a98c)(content(Whitespace\"\\n\"))))(Tile((id \ - c033dba0-3c72-468c-a80e-12e1e2fc8010)(label(let = \ - in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ - Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ - 2))(children(((Secondary((id \ - b1103b7f-de2b-4784-9cfb-5500b2d49513)(content(Whitespace\" \ - \"))))(Projector((id \ - 6aa88bd5-aaa4-4887-85c1-fc95509f3a29)(kind \ - Probe)(syntax(Tile((id \ - 6aa88bd5-aaa4-4887-85c1-fc95509f3a29)(label(a))(mold((out \ - Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ - Convex)(sort \ - Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Secondary((id \ - 7f430bc0-901d-4d23-affc-377c7957c067)(content(Whitespace\" \ - \")))))((Secondary((id \ - 2c67587b-246f-4a7b-ae96-f68f6c2dc94b)(content(Whitespace\"\\n\"))))(Projector((id \ - 2eb8dc02-6f03-42ed-a12e-724f741ddc32)(kind \ + e42f841a-9953-4a78-8433-754794af8049)(content(Whitespace\"\\n\"))))(Projector((id \ + cc0f99f4-f669-4e09-ab49-c8c61137ef8a)(kind \ Probe)(syntax(Tile((id \ - 2eb8dc02-6f03-42ed-a12e-724f741ddc32)(label(10))(mold((out \ + cc0f99f4-f669-4e09-ab49-c8c61137ef8a)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + c76cde1c-39a3-478e-8c16-ca762e1c2af0)(label(4))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort \ - Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Secondary((id \ - f6641228-8da6-4a3f-8388-b81811b0dee8)(content(Whitespace\"\\n\"))))(Tile((id \ - 00309920-7129-49eb-91c1-aa779761937c)(label(*))(mold((out \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 7f72eec6-7abd-46f9-9ad2-171556923530)(content(Whitespace\" \ + \"))))(Tile((id \ + c31e4832-1dde-469e-9a0a-33f1006115e7)(label(*))(mold((out \ Exp)(in_())(nibs(((shape(Concave 26))(sort \ Exp))((shape(Concave 26))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 3e9c74fd-bd87-47d7-9cdb-e84ec281a8d2)(content(Whitespace\" \ - \"))))(Projector((id \ - 8416d273-f869-4b2d-8a92-d282559d0f31)(kind \ - Probe)(syntax(Tile((id \ - 8416d273-f869-4b2d-8a92-d282559d0f31)(label(y))(mold((out \ + 97693e66-72d5-4215-abe6-d0b0df69672f)(content(Whitespace\" \ + \"))))(Tile((id \ + af87a272-b901-4642-ba00-c8eabf171fdd)(label(f))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + a5558001-51c6-4911-b41e-dfbc732632f6)(content(Whitespace\" \ + \"))))(Tile((id \ + 5b5f55e2-9620-4f24-90a8-303918341fd8)(label(-))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 881c5309-baa6-4c9e-ae9c-a6041e48b664)(content(Whitespace\" \ + \"))))(Tile((id \ + 24f814d3-5754-4133-8bfe-7800a782bd1e)(label(4))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ - Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + Exp))))))(shards(0))(children())))))))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - 59e9ecfd-8e8a-4b4d-a558-4585ba186b06)(content(Whitespace\" \ + 2070e7f5-1a9b-4ed3-8b42-a9e548ff82a0)(content(Whitespace\" \ \")))))))))(Secondary((id \ - c459abe0-6c07-4b31-b3bc-571b7c52bf9a)(content(Whitespace\" \ - \"))))(Secondary((id \ - d0b3e592-ef8e-4f87-b930-37b761483036)(content(Whitespace\"\\n\"))))(Tile((id \ - dcd3480d-b336-43ca-a16a-d48f58648016)(label(let = \ + f6c6558b-f412-48c9-8a51-a788b44e9ed7)(content(Whitespace\"\\n\"))))(Secondary((id \ + e2880dd3-3e9c-4fe2-b4c2-07c10167d636)(content(Comment\"# \ + Select `12` below, which reads the argument `t` of `third` \ + #\"))))(Secondary((id \ + 3442b621-9409-4458-b880-fd24ada82816)(content(Whitespace\"\\n\"))))(Tile((id \ + d35bfabb-d398-4b18-a150-f351d931159e)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ 2))(children(((Secondary((id \ - b3799582-de99-4061-b417-cf6d0896d33f)(content(Whitespace\" \ + 102fe5a8-c680-4a8d-8709-811d71142cff)(content(Whitespace\" \ \"))))(Tile((id \ - 16a9176a-35f0-4bc0-8fbe-00dc383830e2)(label(inner))(mold((out \ + f130e49d-aba3-43bd-8346-fec8c01c6fc5)(label(third))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - b293c23d-c771-4551-bd8c-334c7b5dbac5)(content(Whitespace\" \ + f35cba72-07c5-4bd9-afbb-f0d2b22a2e65)(content(Whitespace\" \ \")))))((Secondary((id \ - 107f760c-f964-431e-bd87-4b3dfcf31c87)(content(Whitespace\" \ + fe151c0c-ce3d-4bc9-9227-97e51a0aa3ac)(content(Whitespace\" \ \"))))(Tile((id \ - 42645903-c2bc-4138-9fec-d33cd389926c)(label(fun \ + 301abc18-7d85-4c67-b19a-152cf8dcd25b)(label(fun \ ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - 65949c4d-4dc0-4213-9d7b-1e6f9681d5e1)(content(Whitespace\" \ + b88a1c5f-dcd1-4974-93c9-826b1fa88d7d)(content(Whitespace\" \ \"))))(Projector((id \ - c746675f-f2c5-4506-a061-1e6ca61bdf32)(kind \ + b415fa60-703e-4ed4-a10d-6f4559776823)(kind \ Probe)(syntax(Tile((id \ - c746675f-f2c5-4506-a061-1e6ca61bdf32)(label(z))(mold((out \ + b415fa60-703e-4ed4-a10d-6f4559776823)(label(t))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort \ Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - 688b7961-0d66-4bb9-89d3-2d8dbdba05a4)(content(Whitespace\" \ + 921b48b9-f216-448b-be7a-5bee37cc4af8)(content(Whitespace\" \ \")))))))))(Secondary((id \ - ac00f982-59ad-4d96-b2f7-132ea096ffcc)(content(Whitespace\"\\n\"))))(Projector((id \ - eb7847c4-281c-45b3-98eb-9d980453d225)(kind \ + 45d7b101-b573-4aa9-9e2d-808f46c1472e)(content(Whitespace\" \ + \"))))(Secondary((id \ + 8a64fe08-803e-45ec-baf7-d039afa40451)(content(Whitespace\"\\n\"))))(Secondary((id \ + d8ed669f-85ad-4f1f-a191-db1976736931)(content(Comment\"# Note \ + `32` below is highlit as it's from the same call, \ + #\"))))(Secondary((id \ + edfc04b0-eb7a-4666-ab37-3b6a37732781)(content(Whitespace\"\\n\"))))(Secondary((id \ + 74d2aa8e-7dba-4fac-b055-128baf850ef1)(content(Comment\"# and \ + the `10` below is purple because its the cell of \ + #\"))))(Secondary((id \ + 75c8cba9-318d-45dd-9623-0f240814c139)(content(Whitespace\"\\n\"))))(Secondary((id \ + b4c099c1-7d0b-4469-b852-1205f3b9dcf6)(content(Comment\"# the \ + relevant call to `third`. Now, select `32` below: \ + #\"))))(Secondary((id \ + 9c790c99-85f5-4161-a335-96a8cc16cd3a)(content(Whitespace\"\\n\"))))(Projector((id \ + efdbda6c-ad4a-45b0-9f7e-997608ce3f94)(kind \ Probe)(syntax(Tile((id \ - eb7847c4-281c-45b3-98eb-9d980453d225)(label(\"(\"\")\"))(mold((out \ + efdbda6c-ad4a-45b0-9f7e-997608ce3f94)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - b0d72243-ed26-4c70-b612-dddb92d99315)(label(a))(mold((out \ + eb2ee1dc-1e4f-4613-92ff-7f3cd4a375dd)(label(fourth))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + fd9d5a3d-f0db-4d78-88da-c93cf444c040)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 4cbcb34c-934b-4931-83b5-98ee374a01de)(label(t))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - 12e1fbc2-5cdc-4b4c-bf95-2ead8a40c581)(content(Whitespace\" \ + adfee94c-34b2-4252-80a9-1ccec6446ad6)(content(Whitespace\" \ \"))))(Tile((id \ - 7d982400-433e-46df-9b6d-9903a078b46b)(label(+))(mold((out \ + df671424-204c-45f5-8bd7-0df3e29a8555)(label(-))(mold((out \ Exp)(in_())(nibs(((shape(Concave 27))(sort \ Exp))((shape(Concave 27))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - df35a074-94c6-4d91-99c4-e6abe6d3cb02)(content(Whitespace\" \ + 9c4308fb-9fea-47f1-9a0c-da4b5de763b9)(content(Whitespace\" \ \"))))(Tile((id \ - bb62dca6-680d-4369-b185-1f67c8e95313)(label(2))(mold((out \ + 52fbaa62-288b-425b-9ea4-32cfc11b502e)(label(3))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 901b33b8-2d77-4b42-85c6-f96f7c514c58)(label(*))(mold((out \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 175e08db-4d46-404b-82ee-ab6004481f6f)(content(Whitespace\" \ + \"))))(Tile((id \ + 6a0532d0-defa-41dd-9552-575ac03f5370)(label(/))(mold((out \ Exp)(in_())(nibs(((shape(Concave 26))(sort \ Exp))((shape(Concave 26))(sort \ - Exp))))))(shards(0))(children())))(Tile((id \ - 10bc86f5-9a3e-44f6-af1e-0cc3f4c34f3e)(label(z))(mold((out \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 69475242-7ac8-480b-b574-81086004e703)(content(Whitespace\" \ + \"))))(Tile((id \ + 40a9bed6-b527-464e-8f11-29b491c80f58)(label(3))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort \ - Exp))))))(shards(0))(children())))))))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Secondary((id \ - 09dc6a52-e3ae-40de-9e0e-b9522f4c7ea9)(content(Whitespace\" \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 8d87988d-bd62-4b44-b5d9-74e41f5ab98c)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 0d9dd41c-c722-4676-84e1-9b6aeb648fda)(content(Whitespace\"\\n\"))))(Secondary((id \ + e8b7e763-9d1b-45b7-9c1a-1b02c8ccae47)(content(Whitespace\" \ \"))))(Secondary((id \ - 48554c58-500a-4c9b-929e-60fbd039100e)(content(Whitespace\" \ + 25fa63ea-e6d2-469e-af16-d767e3b1bb8d)(content(Whitespace\" \ \"))))(Secondary((id \ - d551eb83-6401-48e9-b315-cbac4d682338)(content(Whitespace\" \ + ea94e016-53c1-4490-89b9-2cebe784fcda)(content(Comment\"# Note \ + that `10` stays purple as we're still in the same call. \ + #\"))))(Secondary((id \ + 6129d855-247e-496c-b627-455bf239bd62)(content(Whitespace\"\\n\"))))(Secondary((id \ + c48c03ed-107a-49a2-9fd4-fcdd5a7556c6)(content(Whitespace\" \ + \"))))(Secondary((id \ + 1977526c-24ce-47d6-854c-4f4c2380ad7e)(content(Whitespace\" \ + \"))))(Secondary((id \ + d523176d-c7e4-4efa-8f64-c004c7d4dccb)(content(Comment\"# `9` \ + and `32` above get purple outlines as they come from the \ + #\"))))(Secondary((id \ + 15a70d33-ae1a-49e1-b0fd-b4ef81fa214a)(content(Whitespace\"\\n\"))))(Secondary((id \ + 1e0e4a43-fd61-4895-be13-227986820c1f)(content(Whitespace\" \ + \"))))(Secondary((id \ + 269aea03-dac8-4e78-98e7-37d355cb0893)(content(Whitespace\" \ + \"))))(Secondary((id \ + ea37e24e-d762-4f91-9027-28e82a99831d)(content(Comment\"# call \ + to `fourth` that we've now selected#\"))))(Secondary((id \ + ae8940e9-18ac-4881-8bcc-287818dbe598)(content(Whitespace\"\\n\"))))(Tile((id \ + d1ba74d0-8ed3-4a30-bacf-45bf2b2ef9d2)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + b7363479-109c-4cc8-b3be-81537f303114)(content(Whitespace\" \ + \"))))(Tile((id \ + c42b27f9-8833-4e4c-b0f0-266381abeeab)(label(second))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 1ec1a828-bcf9-4534-8e30-4f127d2e4138)(content(Whitespace\" \ + \")))))((Secondary((id \ + e9031146-cf7f-4ddf-9a10-9c631c8f5621)(content(Whitespace\" \ + \"))))(Tile((id \ + c6685701-3932-4485-a9ee-23efed57c09b)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 300d8def-9265-44f8-a3da-d622a8238fba)(content(Whitespace\" \ + \"))))(Projector((id \ + ea6855d4-e2d9-49da-9959-1f2836ee5134)(kind \ + Probe)(syntax(Tile((id \ + ea6855d4-e2d9-49da-9959-1f2836ee5134)(label(s))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 2ee1be25-dfef-4425-a25a-562425ba13c8)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 5b730135-15e6-4322-8ed6-1a0b0ecb2cdd)(content(Whitespace\"\\n\"))))(Projector((id \ - a53be29e-095d-4d84-8994-82fba0135aa2)(kind \ + 9eca80af-103e-4c40-9d4d-cffc3fffd253)(content(Whitespace\"\\n\"))))(Secondary((id \ + 0370dbfc-6f85-4a1c-98b5-4f870c1ab4ad)(content(Comment\"# Now \ + select `10` below, which is a call to `third`: \ + #\"))))(Secondary((id \ + ff092233-29e9-4a75-864b-6b1e1373262c)(content(Whitespace\"\\n\"))))(Projector((id \ + d8b80f6d-ca66-4f59-924d-f21193b089fa)(kind \ Probe)(syntax(Tile((id \ - a53be29e-095d-4d84-8994-82fba0135aa2)(label(\"(\"\")\"))(mold((out \ + d8b80f6d-ca66-4f59-924d-f21193b089fa)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 3c631b4c-254e-46c1-bb94-969299aca825)(label(inner))(mold((out \ + 83ff51e6-1fd8-4572-bb31-cc75ddd19674)(label(third))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 8b213872-054b-4b2e-b3c0-f65f22593ada)(label(\"(\"\")\"))(mold((out \ + 6890df9e-1759-4b95-90b2-c4314ff0b6df)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - fe5a4c79-f803-429c-a63f-80e6020e9122)(label(3))(mold((out \ + e2b985cd-60e7-43e4-958d-4718f04abbf5)(label(2))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 9036ef14-9e80-4636-94b4-375dbaf30248)(label(*))(mold((out \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 56670704-b1d7-49f1-b64a-ab605ca488f5)(content(Whitespace\" \ + \"))))(Tile((id \ + 47cbfa2a-dd14-426c-aaa5-8df036fef201)(label(*))(mold((out \ Exp)(in_())(nibs(((shape(Concave 26))(sort \ Exp))((shape(Concave 26))(sort \ - Exp))))))(shards(0))(children())))(Tile((id \ - 7a85c3e6-698a-43cc-8271-90ff1f94b970)(label(a))(mold((out \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 0e9b96d2-a5d3-4b48-b607-191952c18f2b)(content(Whitespace\" \ + \"))))(Tile((id \ + a159dd1f-1a1a-4af2-a3c2-08e7e3184f25)(label(s))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - 28bf3ad4-9820-446c-a349-797406667036)(content(Whitespace\"\\n\"))))(Tile((id \ - 46e0b99b-1cc4-42ca-92cf-7c7524b1197d)(label(+))(mold((out \ + 5837d481-a939-4ef0-97fb-3fcdc94bb684)(content(Whitespace\" \ + \"))))(Tile((id \ + a6360712-cd42-40d9-b77c-da44be856ef5)(label(+))(mold((out \ Exp)(in_())(nibs(((shape(Concave 27))(sort \ Exp))((shape(Concave 27))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 58457b4d-93fd-4a3c-bbb3-057100a0288e)(content(Whitespace\" \ - \"))))(Projector((id \ - bb7e8c82-548c-4929-968a-c36bf50e2112)(kind \ - Probe)(syntax(Tile((id \ - bb7e8c82-548c-4929-968a-c36bf50e2112)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - e6552a3e-0c4f-45c9-b755-cde3bc74a979)(label(inner))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 14ede4c3-6041-4a91-97e2-02ab0df83dfa)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - c56f4006-72d3-4ce4-acac-c2c8be6cf374)(label(5))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - b0c9ae3a-6c2b-46bc-8539-1f2b02d0cc08)(label(*))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 26))(sort \ - Exp))((shape(Concave 26))(sort \ - Exp))))))(shards(0))(children())))(Tile((id \ - a349aba2-c83d-4787-915f-76713a370dbb)(label(y))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort \ - Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Secondary((id \ - 3d699957-92da-4786-8d5b-564dcaf29a62)(content(Whitespace\" \ + 1d1878cc-be40-4c1e-9093-9526004b14c2)(content(Whitespace\" \ + \"))))(Tile((id \ + 0a44b84e-9fa6-45e8-bd83-a11286a96b8b)(label(2))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + e2b7dbca-a7b3-4774-abf0-59295bf517b0)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 194bacce-ebc6-47bb-a81f-474d25e14f8c)(content(Whitespace\"\\n\"))))(Secondary((id \ + 514e8a18-f1c3-4040-ad1e-ce08d1866505)(content(Whitespace\" \ \"))))(Secondary((id \ - fb590cb3-72e1-4d3c-8b9d-f496cda760b8)(content(Whitespace\" \ + 8bcc21ca-f2eb-47ed-ad75-7d8c9f476d90)(content(Whitespace\" \ \"))))(Secondary((id \ - b67f09f9-cc16-4290-9855-6c87f3586d13)(content(Whitespace\"\\n\")))))))))(Secondary((id \ - f0c7ccbd-0a24-46b9-939a-4dafbe1a02e0)(content(Whitespace\" \ - \"))))(Tile((id \ - 31590c3b-df44-4013-a78c-0cca198f1b4a)(label(let = \ + e432c424-8fd3-48b4-9c30-baa97f8b538b)(content(Comment\"# Note \ + that `32` and `9` stay outlined, but are now dimmed, \ + #\"))))(Secondary((id \ + a462fd1a-1ad4-4711-b4f2-6b84043b9ec3)(content(Whitespace\"\\n\"))))(Secondary((id \ + f0262381-3ea5-4a77-b9a5-56d9362d1eab)(content(Whitespace\" \ + \"))))(Secondary((id \ + a084251c-e653-481c-aa20-502a0313ee2d)(content(Whitespace\" \ + \"))))(Secondary((id \ + edf23633-1cab-47a0-86ca-81f96ad7a968)(content(Comment\"# \ + since they come from a call \\\\in a call\\\\ to `third`. \ + `12` #\"))))(Secondary((id \ + 31f57084-1f32-4c7a-9fff-d5b61a38967f)(content(Whitespace\"\\n\"))))(Secondary((id \ + 9478ae5e-9503-4e32-a9e6-77f075c9cb2c)(content(Whitespace\" \ + \"))))(Secondary((id \ + 9ac6ba9d-edec-46b8-a8e0-2cc53b018fe0)(content(Whitespace\" \ + \"))))(Secondary((id \ + d52592af-52eb-484c-9e7a-e6fed4cec0d5)(content(Comment\"# and \ + the other `32` are outline as they are directly from \ + #\"))))(Secondary((id \ + 36692b75-20e8-4b98-841c-e1350e050f84)(content(Whitespace\"\\n\"))))(Secondary((id \ + ea5c6715-ab9a-4f88-9da8-4ac31ec93209)(content(Whitespace\" \ + \"))))(Secondary((id \ + 07bb069a-2721-4d94-933b-f1e5d5238c6d)(content(Whitespace\" \ + \"))))(Secondary((id \ + b0614927-3a1a-48c0-96c5-e093509dcae3)(content(Comment\"# the \ + call to `third`. #\"))))(Secondary((id \ + 8c5f4629-286a-4837-836b-6a3eca6e848a)(content(Whitespace\"\\n\"))))(Tile((id \ + 5ff3f001-e57c-457b-a793-e1ac39f36b01)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ 2))(children(((Secondary((id \ - 669c8db4-2c50-4950-91a8-3dc7eefbd7c9)(content(Whitespace\" \ + fd4070e2-cd56-4900-a487-32d201315e17)(content(Whitespace\" \ \"))))(Tile((id \ - fc1069d8-b5f7-4b89-9942-8fdcdaee62cf)(label(_))(mold((out \ + ec9e7c80-bc99-4071-a462-436549d0e797)(label(first))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - 445206be-45be-4d9b-b11e-3a5225e8406b)(content(Whitespace\" \ + 8023e887-ef1e-46a1-be1b-f24ffb83c519)(content(Whitespace\" \ \")))))((Secondary((id \ - 49b98f40-e962-4440-8595-dac19922ab6e)(content(Whitespace\" \ - \"))))(Secondary((id \ - e179b26c-24ec-40d2-af7a-fca96781e212)(content(Whitespace\" \ + e525abca-5049-45c8-aec4-4eee6e812953)(content(Whitespace\" \ \"))))(Tile((id \ - 116bdadd-1916-4d9a-bee5-1070938cac88)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Secondary((id \ - b1cedbce-5bbb-41e3-9b19-b7c6875d5df6)(content(Whitespace\"\\n\"))))(Projector((id \ - 4c0af00f-fc68-4a0d-86a9-72ec21ca8142)(kind \ + 4add151a-e3b1-4e04-8dd7-b58328e4f040)(label(fun \ + ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ + 1))(children(((Secondary((id \ + 04772292-fdc8-4b40-9a22-7138c6c9c065)(content(Whitespace\" \ + \"))))(Projector((id \ + 4dba3dc5-6e28-4de1-8427-1e7bb1b92455)(kind \ Probe)(syntax(Tile((id \ - 4c0af00f-fc68-4a0d-86a9-72ec21ca8142)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 96f3d011-9e02-4c75-a73f-d1f924baa3d1)(label(outer))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 91b9e262-82b2-4a56-ac6c-ddcb4c62754c)(label(\"(\"\")\"))(mold((out \ - Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - a76f065e-380f-4b72-865f-588c68bbcbe2)(label(4))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + 4dba3dc5-6e28-4de1-8427-1e7bb1b92455)(label(f))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort \ - Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Tile((id \ - a3532a75-ab50-4760-b986-a19f39892452)(label(,))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 45))(sort \ - Exp))((shape(Concave 45))(sort \ - Exp))))))(shards(0))(children())))(Secondary((id \ - edae6488-6dfa-4876-b435-666b350c6b62)(content(Whitespace\"\\n\"))))(Projector((id \ - 165c1596-820f-4dee-9028-0b4d6eeb3054)(kind \ + Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 30f629a3-ac23-4406-aada-20e87638273b)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + 0f2deaeb-c710-4493-9e0e-b02f0933e5df)(content(Whitespace\" \ + \"))))(Secondary((id \ + 97b6f168-1755-4955-8ed9-67b282cb7967)(content(Whitespace\"\\n\"))))(Projector((id \ + 355ea9a0-0dcb-489f-8b65-a186ff68f6c8)(kind \ Probe)(syntax(Tile((id \ - 165c1596-820f-4dee-9028-0b4d6eeb3054)(label(\"(\"\")\"))(mold((out \ + 355ea9a0-0dcb-489f-8b65-a186ff68f6c8)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 1a39666a-1dca-4d6e-b444-0fda6766fdec)(label(outer))(mold((out \ + 1b1adb02-c753-4c41-84f2-c0d7b1b7092e)(label(second))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - a8fd8565-3b2e-45a1-8164-71fa0a54335e)(label(\"(\"\")\"))(mold((out \ + 0a342842-94a0-48f8-b822-503599390f4a)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 4dd547cd-1d0b-4a8e-b524-8c81506d90e0)(label(6))(mold((out \ + 3bbdf14b-c425-47a9-8564-b9b9bb4a7e47)(label(f))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + c0b40bd6-9bea-4bc8-a2aa-e581d586600d)(content(Whitespace\" \ + \"))))(Tile((id \ + 6afef7d4-2740-4462-a6bc-9861dcab73ff)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + b007c652-05d4-4102-9319-da7f135fcea3)(content(Whitespace\" \ + \"))))(Tile((id \ + 933a09f6-b81e-48c4-b6a2-d38350faa49a)(label(1))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))(Tile((id \ - 63e032f6-46c1-4250-8749-57f7c1ffa9f3)(label(,))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 45))(sort \ - Exp))((shape(Concave 45))(sort \ + 30)(index_offset 0))\")))(Secondary((id \ + 98d68578-38c2-4791-a68f-14195d9e9ba9)(content(Whitespace\" \ + \"))))(Tile((id \ + 365455db-c825-4700-b86a-4aa0695cd7d3)(label(*))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 26))(sort \ + Exp))((shape(Concave 26))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 7cde06b6-a558-4b40-9055-4357ac977a32)(content(Whitespace\"\\n\"))))(Projector((id \ - e4b6e723-5940-49ab-9e3e-7f04de2e822c)(kind \ + 87263b4a-bba0-495a-9b1e-f066feddc0c4)(content(Whitespace\" \ + \"))))(Tile((id \ + d91c14a5-9ca9-4cf3-8285-6410365e0114)(label(2))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + ca96f4e7-fc99-4654-8cd6-52493c01ae4a)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + b4442ac4-cbb9-44f5-9911-7f77a9cdfd7d)(content(Whitespace\"\\n\"))))(Projector((id \ + cd624e97-f51d-4310-b622-6eae20023b8b)(kind \ Probe)(syntax(Tile((id \ - e4b6e723-5940-49ab-9e3e-7f04de2e822c)(label(\"(\"\")\"))(mold((out \ + cd624e97-f51d-4310-b622-6eae20023b8b)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 10dc6700-5e21-4721-95e8-6152a8cb1913)(label(outer))(mold((out \ + e98de5e1-368d-4c62-87e2-70dc67bb07f6)(label(first))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 231add25-cd68-465f-b99f-9becbbf5b7ae)(label(\"(\"\")\"))(mold((out \ + cebdb748-72e4-4d22-b5b7-dfdf2115bd5d)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 742a2288-24e2-4b82-aede-e2e5c81ab0f4)(label(a))(mold((out \ - Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ - Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - 5a16d272-742b-4feb-96a8-c78a634655c8)(content(Whitespace\" \ - \"))))(Tile((id \ - 1552efae-0c33-4d30-a8dc-30e35f9916be)(label(+))(mold((out \ - Exp)(in_())(nibs(((shape(Concave 27))(sort \ - Exp))((shape(Concave 27))(sort \ - Exp))))))(shards(0))(children())))(Secondary((id \ - 1da56a90-47d2-41d4-989e-7ec684250003)(content(Whitespace\" \ - \"))))(Tile((id \ - 13a47487-7d84-47e6-9524-09ca44811475)(label(a))(mold((out \ + fb1c8aaf-7386-470e-a9f0-1c11697d676e)(label(5))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - eab16292-9631-4d40-bac5-f6dfa036f85b)(content(Whitespace\"\\n\")))))))))(Secondary((id \ - ec0d8917-468f-46ac-92ca-a1f50907df0f)(content(Whitespace\" \ + 5a49e6ff-bb58-49bd-93c9-4d1347d2f44e)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 8fecb50f-2939-4937-978f-9db99e0947da)(content(Whitespace\"\\n\"))))(Secondary((id \ - e0601156-9921-41aa-a848-30d206c34d69)(content(Whitespace\"\\n\"))))(Secondary((id \ - 23fc887b-163e-4309-9982-bc89c07b81e9)(content(Comment\"# \ - branching #\"))))(Secondary((id \ - ec617d79-6b2a-496f-b577-11651b18a233)(content(Whitespace\"\\n\"))))(Tile((id \ - 64e70d57-37f8-4c26-9d96-e93dce34b19d)(label(let = \ + 75e108ca-3987-4705-b0ff-fd98eac3832d)(content(Whitespace\"\\n\"))))(Secondary((id \ + 38ab14e8-b614-43e0-967f-ab8de0751a5a)(content(Whitespace\"\\n\"))))(Secondary((id \ + e39807a4-7e88-411b-88b4-d118659ef17d)(content(Comment\"# \ + BRANCHING IN FUNCTIONS #\"))))(Secondary((id \ + 16cfc601-f896-4f12-9cf3-d5290aed9eb1)(content(Whitespace\"\\n\"))))(Tile((id \ + 8df51538-1978-4be0-80a0-3ee27f1bff7a)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ 2))(children(((Secondary((id \ - 5f4da475-9c4f-40cd-b28d-5d0a83271dc0)(content(Whitespace\" \ + 419e221c-557b-43ca-8c12-3374cb06a06b)(content(Whitespace\" \ \"))))(Tile((id \ - 51045512-2211-4eaa-a7a5-4abc122c69f1)(label(cases))(mold((out \ + e96d2945-369d-43d3-b005-de58b46435d1)(label(cases))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - da286f66-e245-462a-9f82-d7af4913dd8b)(content(Whitespace\" \ + 9894117d-a831-452a-9cc9-45525f5607c6)(content(Whitespace\" \ \")))))((Secondary((id \ - 167bba9e-d434-43b3-919f-58d57818cc4c)(content(Whitespace\"\\n\"))))(Tile((id \ - 91a3e37f-6e97-42bb-86d1-899ce0f1c112)(label(fun \ + a3912d0f-4d08-42a5-8211-c4a6f5d44b1b)(content(Whitespace\"\\n\"))))(Secondary((id \ + 63bedade-3a98-4dcd-8195-adcbddda3948)(content(Comment\"# \ + Select `6` then `5` then '4' below: #\"))))(Secondary((id \ + f135f8df-7e21-48c6-b7a0-2cac3f50f077)(content(Whitespace\"\\n\"))))(Tile((id \ + 2f5c0a90-7ee1-4feb-99bd-cd947eeda018)(label(fun \ ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 35))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - 0b9364b7-8bcd-410d-a9be-bc67630246ea)(content(Whitespace\" \ + 582e08b3-0e74-4452-8af5-2edbd0c415c5)(content(Whitespace\" \ \"))))(Projector((id \ - 960d1020-ad14-46c7-946f-d1a85906843b)(kind \ + e23d4644-0a1c-4f67-87b9-62231714a828)(kind \ Probe)(syntax(Tile((id \ - 960d1020-ad14-46c7-946f-d1a85906843b)(label(x))(mold((out \ + e23d4644-0a1c-4f67-87b9-62231714a828)(label(x))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort \ Pat))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - 328be498-b7e3-4401-9df1-7f5c3c0ffa5c)(content(Whitespace\" \ + f6668a8e-3e2e-476e-97a1-3d8546635b82)(content(Whitespace\" \ \")))))))))(Secondary((id \ - e81fc6dd-20bd-4865-b899-2b99260827e0)(content(Whitespace\" \ + c30324b4-a927-49c1-bd7e-e13866dd1b3a)(content(Whitespace\" \ \"))))(Tile((id \ - 201cdcef-e896-4199-9dba-f87f5ac762b4)(label(case \ + 86762137-94c7-40cc-9710-4e4aaece92fd)(label(case \ end))(mold((out Exp)(in_(Rul))(nibs(((shape Convex)(sort \ Exp))((shape Convex)(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - ef77471b-8e5c-4a50-b345-4ad02c3fd966)(content(Whitespace\" \ + 4678c3eb-9aac-4eb9-adba-a31a59507ca0)(content(Whitespace\" \ \"))))(Tile((id \ - 12673ef7-6d7f-4cae-9175-1a433003dd6b)(label(x))(mold((out \ + 0bc2e777-f131-495a-bb1f-de96b072eed4)(label(x))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ - df9d4d91-2da5-49d2-83e6-f1ba536584ac)(content(Whitespace\" \ + a53a3039-d6a5-4160-8539-3485cd29cd37)(content(Whitespace\" \ \"))))(Secondary((id \ - 4adcff49-20c7-46a1-9683-5c1e6f04f194)(content(Whitespace\"\\n\"))))(Tile((id \ - c02cf1ad-b800-4367-becc-8661f3f7d961)(label(| =>))(mold((out \ + 54504598-ff5a-47e2-894f-26b95a876260)(content(Whitespace\"\\n\"))))(Secondary((id \ + 296639cd-4894-4fff-ad26-b0b90d43d19d)(content(Comment\"# Note \ + how each activate exactly one branch below: \ + #\"))))(Secondary((id \ + 71afb479-6482-415e-af35-b5c77fa8ab25)(content(Whitespace\"\\n\"))))(Tile((id \ + 4be2d962-7107-4dfa-ba8e-c69a0e5c1058)(label(| =>))(mold((out \ Rul)(in_(Pat))(nibs(((shape(Concave 41))(sort \ Exp))((shape(Concave 41))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - 2067cd76-cbee-4e04-8fdf-8f335f18840d)(content(Whitespace\" \ + a0eea7af-8b0b-4132-92c5-606b74fd9a9b)(content(Whitespace\" \ \"))))(Tile((id \ - fa2e864e-414c-4f09-81c8-0f728d187dc1)(label(4))(mold((out \ + c4e11b3b-070f-4f0a-8919-e62184795f0f)(label(4))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - c66c330b-48ca-427e-a7fc-4f26f4696e69)(content(Whitespace\" \ + 811941af-615d-4460-a676-db2a5349339b)(content(Whitespace\" \ \")))))))))(Secondary((id \ - a4f0de02-2e1d-4539-89a5-6096f908b9cd)(content(Whitespace\" \ + a7c3b49f-c2b2-45dd-b93a-190b200f3ca5)(content(Whitespace\" \ \"))))(Projector((id \ - bb54c64a-5198-47d0-97c1-30595e61c599)(kind \ + a3403667-1557-4390-8136-786b921ad704)(kind \ Probe)(syntax(Tile((id \ - bb54c64a-5198-47d0-97c1-30595e61c599)(label(true))(mold((out \ + a3403667-1557-4390-8136-786b921ad704)(label(true))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - 9c9992aa-37be-4d73-af70-bc6e7a7761f9)(content(Whitespace\"\\n\"))))(Tile((id \ - ae1f7d67-29bd-4f2e-9d1b-2d7fc742bcfa)(label(| =>))(mold((out \ + 1dc62810-64da-4d13-9dfd-5831dfced3e3)(content(Whitespace\"\\n\"))))(Secondary((id \ + 7273879b-beb7-4071-a7de-fc8452342fbb)(content(Comment\"# \ + Select the `5` above and then the `false` below: \ + #\"))))(Secondary((id \ + 27390f7e-1da9-4d1c-b321-f5cd3d41dcf5)(content(Whitespace\"\\n\"))))(Tile((id \ + 2cb1e61f-de08-46a8-b7c1-3030199bc687)(label(| =>))(mold((out \ Rul)(in_(Pat))(nibs(((shape(Concave 41))(sort \ Exp))((shape(Concave 41))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - 3955f7ca-4578-486e-97a4-660e51182bcf)(content(Whitespace\" \ + 9ea1b8bd-980d-4e71-9bef-72d8045b64e8)(content(Whitespace\" \ \"))))(Tile((id \ - c64b1210-5a98-42ce-848e-ec6be545c255)(label(5))(mold((out \ + e4d33554-fdeb-4b6b-8752-5f76f8a3c5b0)(label(5))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - 4622b447-3c22-42b4-b3f1-a7c990e1e679)(content(Whitespace\" \ + 3e0d0295-e62d-4c08-b612-a59226953ca0)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 5dc72c0f-1e62-4e78-9e96-91f028509f05)(content(Whitespace\" \ + cec3af22-f6d0-4333-8eb7-f8ecb77e3209)(content(Whitespace\" \ \"))))(Projector((id \ - 88029932-8f98-4500-b451-340f66c0b5aa)(kind \ + 5c5878bf-b6fe-4f14-990e-bc6e20c8311c)(kind \ Probe)(syntax(Tile((id \ - 88029932-8f98-4500-b451-340f66c0b5aa)(label(false))(mold((out \ + 5c5878bf-b6fe-4f14-990e-bc6e20c8311c)(label(false))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - 0cdedeee-73d8-4b05-b76c-abe487c41167)(content(Whitespace\"\\n\"))))(Tile((id \ - bd66fab0-c3e1-46d3-8f8b-f121ba570481)(label(| =>))(mold((out \ + 0551c870-96c1-47c1-a782-a4132a5f6d3c)(content(Whitespace\"\\n\"))))(Secondary((id \ + 6e762ae1-6034-4e36-a285-e033503a1351)(content(Comment\"# Note \ + the same things are highlit as both cells are \ + #\"))))(Secondary((id \ + 0a4afa03-f568-4258-8849-5def9513fe5a)(content(Whitespace\"\\n\"))))(Secondary((id \ + d5ee04dc-b268-48f3-b806-84340f7e23bb)(content(Comment\"# from \ + the same call to cases#\"))))(Secondary((id \ + 639df91a-ad63-474d-95e0-0432fd72eafa)(content(Whitespace\"\\n\"))))(Tile((id \ + cc1776aa-89b4-477b-bbab-127de74af993)(label(| =>))(mold((out \ Rul)(in_(Pat))(nibs(((shape(Concave 41))(sort \ Exp))((shape(Concave 41))(sort Exp))))))(shards(0 \ 1))(children(((Secondary((id \ - 7210b1f8-6a7d-4e87-ba16-70d47ec88e2d)(content(Whitespace\" \ + fc3cf54b-42cc-4894-b66f-b741cefe76b0)(content(Whitespace\" \ \"))))(Tile((id \ - a8718a4b-a2f6-4b96-95b9-b3d7f570fd72)(label(_))(mold((out \ + 0115b75e-4bf0-4823-a2b5-5b648c45a8da)(label(_))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - 2bb14b5b-e983-4325-a474-b3c4dddfefa0)(content(Whitespace\" \ + fbd79d5c-94be-44da-ab15-404c19db7e14)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 4f582f57-38c0-43f6-9b84-c479f4ab37d6)(content(Whitespace\" \ + d9178536-2587-426e-8944-a8061e6373c5)(content(Whitespace\" \ \"))))(Projector((id \ - 76fffbdd-2679-47e8-8e82-07672e58a9a1)(kind \ + 0391b8a0-372a-4287-8066-308dc5acc0e2)(kind \ Probe)(syntax(Tile((id \ - 76fffbdd-2679-47e8-8e82-07672e58a9a1)(label(true))(mold((out \ + 0391b8a0-372a-4287-8066-308dc5acc0e2)(label(true))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ Exp))))))(shards(0))(children()))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - 390e5265-ff55-4b8e-81b1-45ac142cc61b)(content(Whitespace\" \ + 47d31cb1-f77a-4e3b-90f4-3913f255486e)(content(Whitespace\" \ \")))))))))(Secondary((id \ - 7d99f5d0-b4d6-43fb-bd9f-b0e39b2c1181)(content(Whitespace\" \ + ef12080f-331e-4c8c-bc23-c542bd1ae245)(content(Whitespace\" \ \"))))(Secondary((id \ - 058fb841-3a1e-47aa-8f6e-c295dd237193)(content(Whitespace\"\\n\")))))))))(Secondary((id \ - 0a71ab58-0971-4057-8832-cd0fa7ed474a)(content(Whitespace\" \ + fce5bf02-e138-44e9-b251-9a770bca056a)(content(Whitespace\" \ + \"))))(Secondary((id \ + face2847-6176-475e-9403-a5394be18871)(content(Whitespace\"\\n\")))))))))(Secondary((id \ + c4ccca77-ab15-41bc-a665-07b6982280ba)(content(Whitespace\" \ + \"))))(Tile((id \ + 9178a18b-9f4c-4657-9075-c95a7352d163)(label(let = \ + in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ + Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ + 2))(children(((Secondary((id \ + 16f2722a-bafe-4531-94ba-41e010d5a479)(content(Whitespace\" \ + \"))))(Tile((id \ + f5cb9b60-a132-4f6d-853b-d49a57a8fd5f)(label(_))(mold((out \ + Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ + Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ + 911b6f8c-2b4a-470f-a3e2-149b69d9c0a1)(content(Whitespace\" \ + \")))))((Secondary((id \ + e4479f5c-6640-41ec-827c-4938006354ba)(content(Whitespace\" \ + \"))))(Tile((id \ + 6d757281-23e5-4eed-94e5-c50171bca21c)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Secondary((id \ + acf8e8e0-c768-4e81-be9a-ec86206670b9)(content(Whitespace\"\\n\"))))(Secondary((id \ + 63d09d0d-6b42-4ccd-98ae-60c1170124d3)(content(Comment\"# \ + Select `true` below and then the `4` cell \ + #\"))))(Secondary((id \ + e413914c-3e8a-464c-9998-49b0fd9008de)(content(Whitespace\"\\n\"))))(Secondary((id \ + f32530b7-90f1-4506-8809-88e96c5979cb)(content(Comment\"# for \ + the argument x to `cases` above. #\"))))(Secondary((id \ + b3476671-b95c-4a3e-83bd-a92d78e0c6fe)(content(Whitespace\"\\n\"))))(Projector((id \ + 45f9c1d8-6ea3-405a-b62a-c5ea1ebf99d9)(kind \ + Probe)(syntax(Tile((id \ + 45f9c1d8-6ea3-405a-b62a-c5ea1ebf99d9)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 2e403537-3961-4787-a743-c227a3105da9)(label(cases))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 53cfcaca-bd07-4c13-b07e-a4a7c0ae42bf)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 6d485cac-18e0-42d9-b668-02ebe48f6fe5)(label(4))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Tile((id \ + 0f5c7e17-6af9-43c9-8992-9aad6fb339e9)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 45))(sort \ + Exp))((shape(Concave 45))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + e0928317-f0ea-4269-9f58-a900dc78331d)(content(Whitespace\"\\n\"))))(Secondary((id \ + b1a19cdc-0dad-43b7-8a80-1e5a0d1ad59d)(content(Comment\"# Note \ + how the same cells stay indicated, but the kind \ + #\"))))(Secondary((id \ + 4e44fff2-d51b-4f44-8420-65504ce86dbd)(content(Whitespace\"\\n\"))))(Secondary((id \ + 5fcfb118-c2e8-4a73-b7c6-332b5bdd683e)(content(Comment\"# of \ + indication changes. The `true` below the `4` above \ + #\"))))(Secondary((id \ + 75e5e97e-f0d0-4444-ad6a-c6cd1adcc40d)(content(Whitespace\"\\n\"))))(Secondary((id \ + 9cc83f18-c05a-46a6-bdf4-68a8aaeb8e60)(content(Comment\"# goes \ + from purple outline (created by the cases(4) call) \ + #\"))))(Secondary((id \ + d1e664ac-9e67-4e94-86e9-e568f8ec069f)(content(Whitespace\"\\n\"))))(Secondary((id \ + 6efa56f5-c7aa-489f-b8fd-9d172a2396e9)(content(Comment\"# to \ + green highlighting (part of the same call as `4`). \ + #\"))))(Secondary((id \ + 0873539a-9518-4619-8baa-493f32a883f2)(content(Whitespace\"\\n\"))))(Secondary((id \ + f18db2ec-c13f-45e3-8488-5175363d57f6)(content(Comment\"# The \ + formerly selected lower `true` is now highlit in \ + #\"))))(Secondary((id \ + bab4b3a9-31dd-4a44-92ec-be5f47eb640c)(content(Whitespace\"\\n\"))))(Secondary((id \ + f990f5be-7a6f-445d-8194-239015680b7c)(content(Comment\"# \ + purple since it indicates the call where `4` lives . \ + #\"))))(Secondary((id \ + 49904549-31ef-4039-89c7-936b4bb825b7)(content(Whitespace\"\\n\"))))(Projector((id \ + 3f04dfdd-fbf4-4e57-9e87-285991ed7560)(kind \ + Probe)(syntax(Tile((id \ + 3f04dfdd-fbf4-4e57-9e87-285991ed7560)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + c4d465d9-072c-46f5-87c6-c80c1d4ff20f)(label(cases))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 9d775566-ec89-4d50-ac22-857c93136a05)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + b5147ffa-2884-4570-93ad-afccaed72014)(label(5))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Tile((id \ + aabf7d1d-6a80-4766-ac05-f1e837759de2)(label(,))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 45))(sort \ + Exp))((shape(Concave 45))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 54a03381-eb59-4d73-ae39-4786bc8272e5)(content(Whitespace\"\\n\"))))(Projector((id \ + 417d1c78-cfa8-4277-a454-63c8f895338f)(kind \ + Probe)(syntax(Tile((id \ + 417d1c78-cfa8-4277-a454-63c8f895338f)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 5289e4b3-c220-4645-bf53-a7e1dc1568b2)(label(cases))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ + 466caa09-a4da-451b-b564-72b3f83d1bd8)(label(\"(\"\")\"))(mold((out \ + Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ + 96f3b987-c9a1-4dff-84dd-a18b2676084e)(label(6))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort \ + Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ + 30)(index_offset 0))\")))(Secondary((id \ + 2ca79749-48bd-4232-b4fa-0a969ec9d87a)(content(Whitespace\"\\n\")))))))))(Secondary((id \ + 9dd57662-30f4-480d-824d-a9b7d7600944)(content(Whitespace\" \ + \")))))))))(Secondary((id \ + f7239c24-2f02-42ce-9dca-6c4599814f85)(content(Whitespace\"\\n\"))))(Secondary((id \ + 10fdb2c6-6379-4f77-9411-feed6e730480)(content(Whitespace\"\\n\"))))(Secondary((id \ + 234dab0b-9d42-4940-99ce-f0c7a4713c68)(content(Comment\"# \ + FUNCTIONS IN FUNCTIONS #\"))))(Secondary((id \ + 8f0d3403-e3c7-410d-8054-cfccef303571)(content(Whitespace\"\\n\")))))((Secondary((id \ + f0c7ccbd-0a24-46b9-939a-4dafbe1a02e0)(content(Whitespace\" \ \"))))(Tile((id \ - 37e515ce-e02c-471f-9a61-8f64506cc814)(label(let = \ + 31590c3b-df44-4013-a78c-0cca198f1b4a)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ Exp))((shape(Concave 38))(sort Exp))))))(shards(0 1 \ 2))(children(((Secondary((id \ - 0614710d-273c-4f99-a41f-39bad3141387)(content(Whitespace\" \ + 669c8db4-2c50-4950-91a8-3dc7eefbd7c9)(content(Whitespace\" \ \"))))(Tile((id \ - ddf38386-d7d9-43dc-a285-f779438361a2)(label(_))(mold((out \ + fc1069d8-b5f7-4b89-9942-8fdcdaee62cf)(label(_))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Secondary((id \ - dace1707-208e-4ff2-85e6-4b94a49be6ff)(content(Whitespace\" \ + 445206be-45be-4d9b-b11e-3a5225e8406b)(content(Whitespace\" \ \")))))((Secondary((id \ - 9b052788-3f41-4a97-953c-6d731374dff0)(content(Whitespace\" \ + 49b98f40-e962-4440-8595-dac19922ab6e)(content(Whitespace\" \ + \"))))(Secondary((id \ + e179b26c-24ec-40d2-af7a-fca96781e212)(content(Whitespace\" \ \"))))(Tile((id \ - 2077cb2f-6d94-428b-b734-c0ee915f7e8a)(label(\"(\"\")\"))(mold((out \ + 116bdadd-1916-4d9a-bee5-1070938cac88)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Secondary((id \ - e949ced5-f756-4b92-a91f-6dc317b8b9f1)(content(Whitespace\"\\n\"))))(Projector((id \ - 7f1bad58-64ce-44d8-8445-578c63a6a796)(kind \ + b1cedbce-5bbb-41e3-9b19-b7c6875d5df6)(content(Whitespace\"\\n\"))))(Projector((id \ + 4c0af00f-fc68-4a0d-86a9-72ec21ca8142)(kind \ Probe)(syntax(Tile((id \ - 7f1bad58-64ce-44d8-8445-578c63a6a796)(label(\"(\"\")\"))(mold((out \ + 4c0af00f-fc68-4a0d-86a9-72ec21ca8142)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 23d6819f-65d3-49b9-b86d-b2e491e53979)(label(cases))(mold((out \ + 96f3d011-9e02-4c75-a73f-d1f924baa3d1)(label(outer))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 328dd473-04d4-4277-9f69-5fed4ae6a9b3)(label(\"(\"\")\"))(mold((out \ + 91b9e262-82b2-4a56-ac6c-ddcb4c62754c)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 3546c73b-0714-4d3e-bbbe-c9eb2766098c)(label(4))(mold((out \ + a76f065e-380f-4b72-865f-588c68bbcbe2)(label(4))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Tile((id \ - 585cf1db-60be-4ade-98cc-6430807ed5d6)(label(,))(mold((out \ + a3532a75-ab50-4760-b986-a19f39892452)(label(,))(mold((out \ Exp)(in_())(nibs(((shape(Concave 45))(sort \ Exp))((shape(Concave 45))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - 4f776d9a-2fee-4b79-86b5-21edbeebd90c)(content(Whitespace\"\\n\"))))(Projector((id \ - 601d967d-3408-4c38-aa3d-cfc1fefbdb13)(kind \ + edae6488-6dfa-4876-b435-666b350c6b62)(content(Whitespace\"\\n\"))))(Projector((id \ + 165c1596-820f-4dee-9028-0b4d6eeb3054)(kind \ Probe)(syntax(Tile((id \ - 601d967d-3408-4c38-aa3d-cfc1fefbdb13)(label(\"(\"\")\"))(mold((out \ + 165c1596-820f-4dee-9028-0b4d6eeb3054)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 2ec21ac9-0bea-405c-a447-8881a7b50343)(label(cases))(mold((out \ + 1a39666a-1dca-4d6e-b444-0fda6766fdec)(label(outer))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 88c5d630-41f7-4853-990d-98362157c526)(label(\"(\"\")\"))(mold((out \ + a8fd8565-3b2e-45a1-8164-71fa0a54335e)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 2c435ab4-cfda-4112-8c21-e361afcc7173)(label(5))(mold((out \ + 4dd547cd-1d0b-4a8e-b524-8c81506d90e0)(label(6))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Tile((id \ - a6c3decb-ac5a-49b4-a8f4-534c837b1943)(label(,))(mold((out \ + 63e032f6-46c1-4250-8749-57f7c1ffa9f3)(label(,))(mold((out \ Exp)(in_())(nibs(((shape(Concave 45))(sort \ Exp))((shape(Concave 45))(sort \ Exp))))))(shards(0))(children())))(Secondary((id \ - db0c135d-ecc3-4989-b16e-402185094290)(content(Whitespace\"\\n\"))))(Projector((id \ - 148b0f50-6b23-47ce-b929-bba5b430cc54)(kind \ + 7cde06b6-a558-4b40-9055-4357ac977a32)(content(Whitespace\"\\n\"))))(Projector((id \ + e4b6e723-5940-49ab-9e3e-7f04de2e822c)(kind \ Probe)(syntax(Tile((id \ - 148b0f50-6b23-47ce-b929-bba5b430cc54)(label(\"(\"\")\"))(mold((out \ + e4b6e723-5940-49ab-9e3e-7f04de2e822c)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - 8814b0a8-85c3-42e8-96ae-dd3f46f3048b)(label(cases))(mold((out \ + 10dc6700-5e21-4721-95e8-6152a8cb1913)(label(outer))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0))(children())))(Tile((id \ - 5831e5d5-ae89-44c7-8045-c212d091fece)(label(\"(\"\")\"))(mold((out \ + 231add25-cd68-465f-b99f-9becbbf5b7ae)(label(\"(\"\")\"))(mold((out \ Exp)(in_(Exp))(nibs(((shape(Concave 22))(sort Exp))((shape \ Convex)(sort Exp))))))(shards(0 1))(children(((Tile((id \ - e60a6b2b-ab79-4522-9685-66c61a67aced)(label(6))(mold((out \ + d134a9c5-bdce-4088-85cb-37092e366a63)(label(4))(mold((out \ + Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ + Convex)(sort Exp))))))(shards(0))(children())))(Secondary((id \ + 5a16d272-742b-4feb-96a8-c78a634655c8)(content(Whitespace\" \ + \"))))(Tile((id \ + 1552efae-0c33-4d30-a8dc-30e35f9916be)(label(+))(mold((out \ + Exp)(in_())(nibs(((shape(Concave 27))(sort \ + Exp))((shape(Concave 27))(sort \ + Exp))))))(shards(0))(children())))(Secondary((id \ + 1da56a90-47d2-41d4-989e-7ec684250003)(content(Whitespace\" \ + \"))))(Tile((id \ + 92b1c66c-ee14-4e5e-b1c5-654928572d4c)(label(4))(mold((out \ Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ - 83599d4c-a3a7-40ec-9de0-d363918918f1)(content(Whitespace\"\\n\")))))))))(Secondary((id \ - b1b2fe71-47aa-4b7a-bb0a-f1031bc2ed58)(content(Whitespace\" \ + eab16292-9631-4d40-bac5-f6dfa036f85b)(content(Whitespace\"\\n\")))))))))(Secondary((id \ + ec0d8917-468f-46ac-92ca-a1f50907df0f)(content(Whitespace\" \ \")))))))))(Secondary((id \ 803b1153-93dc-4548-b67e-63ff592b6c00)(content(Whitespace\"\\n\"))))(Secondary((id \ ed717a7a-068b-4ef2-a808-0b2b182616ab)(content(Whitespace\"\\n\"))))(Secondary((id \ - 4cf408d7-e94a-4869-a538-dc89fa03ce2d)(content(Comment\"# \ - recursion #\"))))(Secondary((id \ + 615f17f8-5a69-461e-8b9a-a9539c2b3bcb)(content(Comment\"# \ + RECURSION #\"))))(Secondary((id \ 5276808f-1f94-49d8-8a68-d35cf4d1375b)(content(Whitespace\"\\n\"))))(Tile((id \ 953a0f2c-a18e-48ff-b8ab-4363443814bf)(label(let = \ in))(mold((out Exp)(in_(Pat Exp))(nibs(((shape Convex)(sort \ @@ -1060,7 +1782,7 @@ let startup : PersistentData.t = 2))(children(((Secondary((id \ 845a0640-839c-4649-b11c-298ac5e9f741)(content(Whitespace\" \ \"))))(Tile((id \ - e24fa925-ec68-4477-b24c-85a3af462bdf)(label(fib))(mold((out \ + 8412bbd7-b7a6-4391-a4e1-ee6245f36c76)(label(fib))(mold((out \ Pat)(in_())(nibs(((shape Convex)(sort Pat))((shape \ Convex)(sort Pat))))))(shards(0))(children())))(Tile((id \ 3fab4407-877d-4759-a203-19efbbe02a37)(label(:))(mold((out \ @@ -1085,6 +1807,13 @@ let startup : PersistentData.t = Convex)(sort Typ))))))(shards(0))(children())))(Secondary((id \ 039cea30-dbd8-481f-926b-b0bfd8d7456e)(content(Whitespace\" \ \")))))((Secondary((id \ + cc4b9c25-8e26-4187-b770-fed18f904b52)(content(Whitespace\"\\n\"))))(Secondary((id \ + d82e8e94-caaf-48e8-b152-3a6c1e767b57)(content(Comment\"# \ + Recursive calls can complicate probe display due \ + #\"))))(Secondary((id \ + de0d3cbd-f0ea-4bab-8d5a-8ec24da533fd)(content(Whitespace\"\\n\"))))(Secondary((id \ + e4d221fe-b137-41fb-9231-f3a27e823af2)(content(Comment\"# due \ + to overlapping information channels.#\"))))(Secondary((id \ 55e31bfc-9841-43fe-ba37-c09ab971dad8)(content(Whitespace\"\\n\"))))(Tile((id \ 64995a45-4dba-4c4e-9382-79f573fba433)(label(fun \ ->))(mold((out Exp)(in_(Pat))(nibs(((shape Convex)(sort \ @@ -1176,6 +1905,9 @@ let startup : PersistentData.t = \"))))(Secondary((id \ f9f719ce-0db3-4a90-b2fe-202996b72912)(content(Whitespace\" \ \"))))(Secondary((id \ + 583884b6-7031-48f1-9bec-7f5471fefd9e)(content(Whitespace\"\\n\"))))(Secondary((id \ + f0f9c7de-181d-440a-ae90-3a6efb931b80)(content(Comment\"# \ + Select the first `1` below: #\"))))(Secondary((id \ a2e1370d-263c-46ad-b102-e99d9b5fdbd3)(content(Whitespace\"\\n\"))))(Projector((id \ 92889848-c7f6-48df-bafa-53fec43b90ca)(kind \ Probe)(syntax(Tile((id \ @@ -1200,6 +1932,33 @@ let startup : PersistentData.t = Convex)(sort \ Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ 30)(index_offset 0))\")))(Secondary((id \ + dea768f6-5c16-4f5d-87a0-2dc0e4a1e1d7)(content(Whitespace\"\\n\"))))(Secondary((id \ + 2fb0dc74-8a03-4bbf-9ab9-4175ee599bcb)(content(Comment\"# Note \ + the purple `2` below corresponding the call \ + #\"))))(Secondary((id \ + a4d1984f-af90-4f40-8dde-5a8e8d94f292)(content(Whitespace\"\\n\"))))(Secondary((id \ + 5efbec55-a911-4af0-b4f3-b9e9dafac26c)(content(Comment\"# \ + fib(4-2) which contains the above `1`. The `1` below \ + #\"))))(Secondary((id \ + 3602dfd4-0c68-4199-9445-45137f2aa8b4)(content(Whitespace\"\\n\"))))(Secondary((id \ + 6eda1e61-6bfe-4ffe-9f47-788fb6b139f9)(content(Comment\"# OTOH \ + is highlit because when the above call was made, \ + #\"))))(Secondary((id \ + ab635a3a-44f5-4190-885f-28606c9b3b94)(content(Whitespace\"\\n\"))))(Secondary((id \ + 797f467b-7ede-42c9-bc67-3322aa4c8a2e)(content(Comment\"# the \ + call below had that value. The two `1s` outline in \ + #\"))))(Secondary((id \ + fa4f28b9-679d-4a30-968a-ba1680871749)(content(Whitespace\"\\n\"))))(Secondary((id \ + f8befcab-9928-4744-84c9-6795774c272f)(content(Comment\"# \ + purple above come /from/ the indicated call, whereas the \ + #\"))))(Secondary((id \ + 2a3c394c-bb8a-44b1-a068-0afb978ea9ba)(content(Whitespace\"\\n\"))))(Secondary((id \ + cd93b56a-7c9e-4cd5-8315-c743a41d9644)(content(Comment\"# \ + highlit `2`s are from the /same/ call the indicated call \ + #\"))))(Secondary((id \ + 9d4a1042-11e2-4233-9fa0-4179134b6b55)(content(Whitespace\"\\n\"))))(Secondary((id \ + 81f3f6af-b197-4a7d-835f-777603ea4c2b)(content(Comment\"# was \ + evaluated in. #\"))))(Secondary((id \ 9f5da5f3-8957-4dbd-b760-c2c654406f6c)(content(Whitespace\"\\n\"))))(Tile((id \ 10ba6aec-a296-4616-9f66-c07bfc457389)(label(+))(mold((out \ Exp)(in_())(nibs(((shape(Concave 27))(sort \ @@ -1319,74 +2078,194 @@ let startup : PersistentData.t = Exp)(in_())(nibs(((shape Convex)(sort Exp))((shape \ Convex)(sort \ Exp))))))(shards(0))(children()))))))))))))))(model\"((display_lengths())(max_closures \ - 30)(index_offset 0))\")))))))))))(ancestors())))(caret(Inner \ - 0 46)))"; + 30)(index_offset 0))\"))))))))(Secondary((id \ + 52d4807f-d9fb-4409-b655-d2252754b948)(content(Whitespace\"\\n\"))))(Secondary((id \ + af4c152a-09bc-4bdd-bb82-0bb3f943e19a)(content(Whitespace\"\\n\"))))(Secondary((id \ + 8b23b024-6f92-40f3-ad68-827ebbd72487)(content(Comment\"# \ + ADVANCED FEATURES #\"))))(Secondary((id \ + f4660d47-fb9e-4bdb-b662-d31359e24157)(content(Whitespace\"\\n\"))))(Secondary((id \ + 093e6b59-7951-4c1b-a311-272636c40c76)(content(Comment\"# - \ + You can resize a cell by holding shift and dragging \ + horizontally #\")))))))))))(caret Outer))"; backup_text = - "# PROBE PROJECTORS #\n\n\ - # You can use the bottom-right projector panel #\n\ - # or alt/option-v (for value) to display live #\n\ - # values for an expression at the end of the #\n\ - # line. You can select any such value to see #\n\ - # any environment variables reference in the #\n\ - # probed expression. If the probed expression #\n\ - # is inside a function, the corresponding ap #\n\ - # (if also probed) will be filled in purple. #\n\ - # If the probed expression is an ap, values in #\n\ - # the relevant function definition closure, if #\n\ - # projected, will be outlined in purple. #\n\n\ - # top-level unconditional evaluation #\n\ - let a = (10 + 10) in\n\ - let b = (3 * a) in\n\n\ - # functions calling functions #\n\ - let fifth = fun x ->\n\ - (7*x) in\n\ - let fourth = fun x -> \n\ - (fifth(x - 4)) + 1 in\n\ - let third = fun x -> \n\ - (fourth(x)) / 4 in\n\ - let second = fun x -> \n\ - (third(3 * x)) + 1 in\n\ - let first = fun x -> \n\ - (second(x + 2)) * 2 in\n\ - let _ = (first(5)) in\n\n\ - # functions in functions #\n\ + "# _____ _ #\n\ + # | __ \\ | | #\n\ + # | |__) | __ ___ | |__ ___ ___ #\n\ + # | ___/ '__/ _ \\| '_ \\ / _ \\/ __| #\n\ + # | | | | | (_) | |_) | __/\\__ \\ #\n\ + # |_| |_| \\___/|_.__/ \\___||___/ #\n\ + # INLINE EVAL WITH PROBE PROJECTORS #\n\n\ + # INTRODUCTION #\n\n\ + # Probe projectors are a kind of inline evaluation, #\n\ + # similar to value hints in Emacs or IntelliJ. #\n\n\ + # You can put these on any expression or variable binding to #\n\ + # see a list of all values taken on by that \ + expression/pattern. #\n\ + # By default values are sorted by left-to-right by \ + most-recent. #\n\n\ + # More generally, each cell represents a stack state, #\n\ + # including the top stack frame / closure and hence the #\n\ + # expression's value, the values of environment variables, #\n\ + # as well as the surrounding call stack context. #\n\n\ + # When a cell is selected, you can hover over it to see #\n\ + # relevant environment variables, and all /other/ cells #\n\ + # are decorated according to their relative position in #\n\ + # to the selected cell. in the context #\n\n\ + # Probe are intended mostly as a println replacement #\n\ + # for exposing intermediate values, with the above \ + decorations #\n\ + # as a supporting feature to help maintain context when #\n\ + # navigating between multiple probed expressions, which #\n\ + # may take on many values across nested or recursive \ + functions. #\n\n\n\ + # TUTORIAL #\n\n\ + # The expression (10 * 10) below has a probe. #\n\ + # Its value, 20, is shown in a cell to the right. #\n\ + let sum = (10 + 10) in\n\n\ + # To probe the below expression, put your caret to #\n\ + # left of the `(` and press option/alt-v (for value), #\n\ + # or select `Probe` from the lower right corner menu: #\n\ + let drink_me = (1 + 2 * 3) in\n\ + # The expression should be encased in a green block #\n\ + # and a cell reading `7` should appear to the right. #\n\ + # The same shortcut or menu toggle removes it. #\n\n\ + # Click the below cell (with value 60) to select it. #\n\ + let thrice = (3 * drink_me) in\n\ + # Notice when you hover over a selected cell, it #\n\ + # shows the values of any contained variables. #\n\n\ + # Probes only have cells if the are evaluated. #\n\ + # Below, only the first case branch is evaluated. #\n\ + let maybe = if true then thrice else 0 in\n\ + let _ = case maybe\n\ + | 21 => \"necessary\"\n\ + | _ => \"impossible\"\n\ + end in\n\ + # Note the 2nd branch probe has a zero to the right. #\n\ + # This is the cell's collected closure count, i.e. #\n\ + # the number of times the expression was evaluated #\n\n\ + # Probes can be placed on expressions: #\n\ + let story = (50 ** 2) in\n\ + # And also on patterns (e.g. variables), shown in blue: #\n\ + let story = 50 ** 2 in\n\ + # Expressions currently CAN'T BE EDITED WHILE PROBED #\n\ + # So probing a name instead makes iteration easier. #\n\n\n\ + # FUNCTIONS #\n\ + let _ =\n\ + # Because functions can run multiple times, they can #\n\ + # have multiple cells. Note the closure counts below #\n\ + # are all 2, indicating each probe was evaluated twice. #\n\ + let celcius = fun farenheit ->\n\ + # Click to select the cell above reading 72.5 #\n\ + let diff = (farenheit -. 32.) in\n\ + # This highlights cells below corresponding to the same #\n\ + # function call: the cells reading 40.5 and 22.5) #\n\ + (5./.9. *. diff) in\n\ + let (t1, t2) = 72.5, 103.1 in (\n\ + # It also highlights in purple the cell #\n\ + # of the function's call site#\n\ + (celcius(t1)),\n\ + # Now select the cell above reading 22.5 #\n\ + (celcius(t2))\n\ + # Note the 103.1, 71.1, and 39.5 are no longer green-highlit #\n\ + # as they are not part of the same call as /the expression/ #\n\ + # `celcius(t1)`. However, they are now outlined in purple, as #\n\ + # they are contained in the callstack created by that call #\n\ + ) in\n\n\n\ + # FUNCTIONS CALLING FUNCTIONS #\n\ + let _ =\n\ + let fourth = fun f ->\n\ + (4 * f - 4) in\n\ + # Select `12` below, which reads the argument `t` of `third` #\n\ + let third = fun t -> \n\ + # Note `32` below is highlit as it's from the same call, #\n\ + # and the `10` below is purple because its the cell of #\n\ + # the relevant call to `third`. Now, select `32` below: #\n\ + (fourth(t - 3)) / 3 in\n\ + \ # Note that `10` stays purple as we're still in the same \ + call. #\n\ + \ # `9` and `32` above get purple outlines as they come from \ + the #\n\ + \ # call to `fourth` that we've now selected#\n\ + let second = fun s ->\n\ + # Now select `10` below, which is a call to `third`: #\n\ + (third(2 * s)) + 2 in\n\ + \ # Note that `32` and `9` stay outlined, but are now dimmed, #\n\ + \ # since they come from a call \\in a call\\ to `third`. \ + `12` #\n\ + \ # and the other `32` are outline as they are directly from #\n\ + \ # the call to `third`. #\n\ + let first = fun f -> \n\ + (second(f + 1)) * 2 in\n\ + (first(5)) in\n\n\ + # BRANCHING IN FUNCTIONS #\n\ + let cases =\n\ + # Select `6` then `5` then '4' below: #\n\ + fun x -> case x \n\ + # Note how each activate exactly one branch below: #\n\ + | 4 => true\n\ + # Select the `5` above and then the `false` below: #\n\ + | 5 => false\n\ + # Note the same things are highlit as both cells are #\n\ + # from the same call to cases#\n\ + | _ => true end \n\ + in let _ = (\n\ + # Select `true` below and then the `4` cell #\n\ + # for the argument x to `cases` above. #\n\ + (cases(4)),\n\ + # Note how the same cells stay indicated, but the kind #\n\ + # of indication changes. The `true` below the `4` above #\n\ + # goes from purple outline (created by the cases(4) call) #\n\ + # to green highlighting (part of the same call as `4`). #\n\ + # The formerly selected lower `true` is now highlit in #\n\ + # purple since it indicates the call where `4` lives . #\n\ + (cases(5)),\n\ + (cases(6))\n\ + ) in\n\n\ + # FUNCTIONS IN FUNCTIONS #\n\ let outer = fun y ->\n\ + # Select `40` then `6` then '4' above. #\n\ let a =\n\ 10\n\ * y in \n\ + # Note how inside the `inner` function below #\n\ + # two cells for each probe gets highlighted. #\n\ let inner = fun z ->\n\ (a + 2*z) in\n\ + # This is because there are two calls to `inner` #\n\ + # below for each call to the containing `outer`. #\n\ (inner(3*a))\n\ + (inner(5*y)) \n\ in let _ = (\n\ (outer(4)),\n\ (outer(6)),\n\ - (outer(a + a))\n\ - ) in\n\n\ - # branching #\n\ - let cases =\n\ - fun x -> case x \n\ - | 4 => true\n\ - | 5 => false\n\ - | _ => true end \n\ - in let _ = (\n\ - (cases(4)),\n\ - (cases(5)),\n\ - (cases(6))\n\ + (outer(4 + 4))\n\ ) in\n\n\ - # recursion #\n\ + # RECURSION #\n\ let fib: Int -> Int =\n\ + # Recursive calls can complicate probe display due #\n\ + # due to overlapping information channels.#\n\ fun x -> case x\n\ | 0 => 1\n\ | 1 => 1\n\ | n => \n\ + # Select the first `1` below: #\n\ (fib(x-1))\n\ + # Note the purple `2` below corresponding the call #\n\ + # fib(4-2) which contains the above `1`. The `1` below #\n\ + # OTOH is highlit because when the above call was made, #\n\ + # the call below had that value. The two `1s` outline in #\n\ + # purple above come /from/ the indicated call, whereas the #\n\ + # highlit `2`s are from the /same/ call the indicated call #\n\ + # was evaluated in. #\n\ + (fib(x-2)) end \n\ in (\n\ (fib(1)),\n\ (fib(2)),\n\ (fib(3)),\n\ - (fib(4)))"; + (fib(4)))\n\n\ + # ADVANCED FEATURES #\n\ + # - You can resize a cell by holding shift and dragging \ + horizontally #"; } ); ( "Casting", { From 71cf5984774c8996a5c102cda71df9b6b8e547d8 Mon Sep 17 00:00:00 2001 From: disconcision Date: Wed, 15 Jan 2025 00:20:49 -0500 Subject: [PATCH 269/281] group probe cells according to call --- src/haz3lcore/zipper/projectors/ProbeProj.re | 59 +++++++++++++++++++- src/haz3lweb/www/style/projectors/probe.css | 12 ++++ src/util/ListUtil.re | 10 ++++ 3 files changed, 78 insertions(+), 3 deletions(-) diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index a57f0e9334..1c7d355d46 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -284,7 +284,7 @@ let closure_view = @ (is_var_ref(info) ? [] : [env_view(closure, utility)]), ); -let select_vals = (model: model, vals) => { +let select_frames = (model: model, vals) => { switch (List.sort(comparor, vals)) { | [] => [] | _ => @@ -324,19 +324,72 @@ let nav_forward = (di, model, local, right_cond) => ] : []; +let group_by_predicate = + (should_join_group: ('a, 'a) => bool, xs: list('a)): list(list('a)) => { + List.fold_left( + (acc: list(list('a)), x: 'a) => { + switch (acc) { + | [] => [[x]] + | [[rep, ..._] as first, ...init] when should_join_group(rep, x) => [ + first @ [x], + ...init, + ] + | _ => [[x]] @ acc + } + }, + [], + xs, + ); +}; + +let group_closures = + (closures: list(Dynamics.Probe.Closure.t)) + : list(list(Dynamics.Probe.Closure.t)) => { + let should_join_group = + (first: Dynamics.Probe.Closure.t, curr: Dynamics.Probe.Closure.t) => { + switch (List.rev(curr.dyn_stack), List.rev(first.dyn_stack)) { + | ([], _) => false + | (_, []) => false + | ([f1, ..._], [f2, ..._]) => f1 == f2 + }; + }; + let grouped = group_by_predicate(should_join_group, closures); + let grouped = List.map(List.rev, grouped); + /* Flatten if all groups are singletons */ + List.for_all( + (group: list(Dynamics.Probe.Closure.t)) => List.length(group) == 1, + grouped, + ) + ? [List.concat(grouped)] : grouped; +}; + +let closure_group_view = + (info, utility, model, local, closures: list(Dynamics.Probe.Closure.t)) => { + let groups: list(list(Dynamics.Probe.Closure.t)) = + group_closures(closures); + List.map( + closures => + Node.div( + ~attrs=[Attr.classes(["closure-group"])], + List.map(closure_view(info, utility, model, local), closures), + ), + groups, + ); +}; + let offside_view = (model: model, ~info, ~local, ~parent as _, ~utility: utility) => { Node.div( ~attrs=[Attr.classes(["live-offside"])], switch (info.dynamics) { | Some(di) => - let vals = select_vals(model, di); + let frames = select_frames(model, di); let left_cond = model.index_offset >= List.length(di) - model.max_closures; let right_cond = model.index_offset <= 0; nav_back(di, model, local, left_cond) @ nav_forward(di, model, local, right_cond) - @ List.map(closure_view(info, utility, model, local), vals); + @ closure_group_view(info, utility, model, local, frames); | _ => [] }, ); diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index af522a6df2..49deaf3f66 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -109,6 +109,18 @@ display: none; } +.projector.probe .closure-group { + display: flex; + gap: 2px; + align-items: center; +} + +.projector.probe .closure-group:not(:last-child)::after { + content: "•"; + font-size: 0.4em; + color: var(--exp-indicated); +} + .projector.probe .val-resize { cursor: pointer; } diff --git a/src/util/ListUtil.re b/src/util/ListUtil.re index 4c47e92db0..b02311e8fe 100644 --- a/src/util/ListUtil.re +++ b/src/util/ListUtil.re @@ -638,3 +638,13 @@ let rec rotate_n = (n: int, xs: list('a)): list('a) => { | _ => rotate_n(n - 1, rotate(xs)) }; }; + +let take = (n, xs) => { + let rec loop = (n, xs, acc) => + switch (n, xs) { + | (0, _) => acc + | (_, []) => acc + | (n, [x, ...xs]) => loop(n - 1, xs, [x, ...acc]) + }; + loop(n, xs, []); +}; From 474fe8429bd7e35b95ed58e4a8dbc9ae215f4c1f Mon Sep 17 00:00:00 2001 From: disconcision Date: Wed, 15 Jan 2025 00:26:42 -0500 Subject: [PATCH 270/281] cleanup --- src/haz3lcore/zipper/projectors/ProbeProj.re | 50 +++++++++----------- 1 file changed, 22 insertions(+), 28 deletions(-) diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index 1c7d355d46..fb182eda15 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -325,16 +325,17 @@ let nav_forward = (di, model, local, right_cond) => : []; let group_by_predicate = - (should_join_group: ('a, 'a) => bool, xs: list('a)): list(list('a)) => { + /* Precondition: Items to be grouped are contigious in list */ + (should_group: ('a, 'a) => bool, xs: list('a)): list(list('a)) => { List.fold_left( - (acc: list(list('a)), x: 'a) => { + (acc: list(list('a)), item: 'a) => { switch (acc) { - | [] => [[x]] - | [[rep, ..._] as first, ...init] when should_join_group(rep, x) => [ - first @ [x], + | [] => [[item]] + | [[rep, ..._] as first, ...init] when should_group(rep, item) => [ + first @ [item], ...init, ] - | _ => [[x]] @ acc + | _ => [[item]] @ acc } }, [], @@ -345,37 +346,30 @@ let group_by_predicate = let group_closures = (closures: list(Dynamics.Probe.Closure.t)) : list(list(Dynamics.Probe.Closure.t)) => { - let should_join_group = - (first: Dynamics.Probe.Closure.t, curr: Dynamics.Probe.Closure.t) => { - switch (List.rev(curr.dyn_stack), List.rev(first.dyn_stack)) { - | ([], _) => false + let is_same_call = + (c1: Dynamics.Probe.Closure.t, c2: Dynamics.Probe.Closure.t) => { + switch (List.rev(c2.dyn_stack), List.rev(c1.dyn_stack)) { + | ([], _) | (_, []) => false | ([f1, ..._], [f2, ..._]) => f1 == f2 }; }; - let grouped = group_by_predicate(should_join_group, closures); - let grouped = List.map(List.rev, grouped); + let grouped = + closures |> group_by_predicate(is_same_call) |> List.map(List.rev); /* Flatten if all groups are singletons */ - List.for_all( - (group: list(Dynamics.Probe.Closure.t)) => List.length(group) == 1, - grouped, - ) + List.for_all(group => List.length(group) == 1, grouped) ? [List.concat(grouped)] : grouped; }; let closure_group_view = - (info, utility, model, local, closures: list(Dynamics.Probe.Closure.t)) => { - let groups: list(list(Dynamics.Probe.Closure.t)) = - group_closures(closures); - List.map( - closures => - Node.div( - ~attrs=[Attr.classes(["closure-group"])], - List.map(closure_view(info, utility, model, local), closures), - ), - groups, - ); -}; + (info, utility, model, local, closures: list(Dynamics.Probe.Closure.t)) => + group_closures(closures) + |> List.map(closures => + Node.div( + ~attrs=[Attr.classes(["closure-group"])], + List.map(closure_view(info, utility, model, local), closures), + ) + ); let offside_view = (model: model, ~info, ~local, ~parent as _, ~utility: utility) => { From 3925e0a8baf532a946b7f2cb694fefe182e491c7 Mon Sep 17 00:00:00 2001 From: disconcision Date: Wed, 15 Jan 2025 00:40:48 -0500 Subject: [PATCH 271/281] probe css cleanup --- src/haz3lweb/www/style/projectors/probe.css | 58 +++++++++------------ 1 file changed, 25 insertions(+), 33 deletions(-) diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index 49deaf3f66..a8a9128447 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -11,6 +11,7 @@ --exp-indicated: var(--G0); --pat-indicated: var(--PAT); + --exp-ap-indicated: var(--TYP); --exp-base: hsl(120, 40%, 85%); --pat-base: hsl(170, 40%, 85%); @@ -28,7 +29,7 @@ color: var(--code-text); } -.projector.probe > svg { +.projector.probe.Exp > svg { fill: var(--exp-base); filter: drop-shadow(0.7px 0.7px 0px var(--exp-shadow)); } @@ -77,13 +78,15 @@ font-family: var(--ui-font); display: flex; justify-content: center; - background-color: var(--exp-indicated); border-radius: 2em; font-size: 0.7em; padding: 0.3em; min-width: 1em; z-index: var(--code-emblems-z); } +.projector.probe.Exp .num-closures { + background-color: var(--exp-indicated); +} .projector.probe.Pat .num-closures { background-color: var(--pat-indicated); } @@ -92,8 +95,6 @@ } .projector.probe.indicated.Right .num-closures { background-color: var(--num-closures-indicated); -} -.projector.probe.indicated.Right .num-closures { right: -0.8em; top: -0.5em; } @@ -101,10 +102,9 @@ .projector.probe .live-offside { display: flex; flex-direction: row; - gap: 2px; align-items: center; + gap: 2px; } - .projector.probe .live-offside:empty { display: none; } @@ -131,38 +131,35 @@ /* TOKEN BKG */ .projector.probe .val-resize .code-text { + border-radius: 0.05em 0.05em 0.05em 0.2em; +} +.projector.probe.Exp .val-resize .code-text { background-color: var(--exp-base); border-bottom: 1px solid var(--exp-shadow); - border-radius: 0.05em 0.05em 0.05em 0.2em; } .projector.probe.Pat .val-resize .code-text { border-color: var(--pat-shadow); background-color: var(--pat-base); } -/* TOKEN OPACITY */ .projector.probe .val-resize.cursor-lex .code-text { opacity: 100%; } .projector.probe .val-resize.cursor-ap-lex .code-text { opacity: 100%; - outline: 1px solid var(--TYP); + outline: 1px solid var(--exp-ap-indicated); } .projector.probe .val-resize.cursor-outer-ap .code-text { opacity: 100% !important; - outline: 1px solid var(--TYP); - background-color: var(--TYP); -} -/* .projector.probe .val-resize.cursor-ap .code-text { - opacity: 100%; - outline: 1px dotted var(--TYP); -} */ -.projector.probe .val-resize .code-text { - opacity: 51%; + outline: 1px solid var(--exp-ap-indicated); + background-color: var(--exp-ap-indicated); } +.projector.probe .val-resize .code-text, .projector.probe .val-resize.cursor-ap.light .code-text, .projector.probe .val-resize.cursor-ap-lex.light .code-text { - opacity: 45%; + opacity: 50%; } + +/* TOKEN BKG INDICATED */ .projector.probe.indicated .val-resize .code-text { opacity: 60%; } @@ -172,29 +169,24 @@ outline-width: 2.8px; outline-style: solid; } -.projector.probe.indicated .val-resize.cursor-lex .code-text { +.projector.probe.indicated.Exp .val-resize.cursor-lex .code-text { outline-color: var(--exp-indicated); } -.projector.probe.indicated .val-resize.cursor-lex.ap .code-text { - outline-color: var(--TYP); -} .projector.probe.indicated.Pat .val-resize.cursor-lex .code-text { outline-color: var(--pat-indicated); } -/* TOKENS */ -.projector.probe .val-resize.cursor-ap .code-text .token { - filter: invert(1) brightness(10); - /* color: var(--TYP); */ +.projector.probe.indicated .val-resize.cursor-lex.ap .code-text { + outline-color: var(--exp-ap-indicated); } -.projector.probe .val-resize.cursor-none .code-text .token { + +/* TOKENS */ +.projector.probe .val-resize.cursor-ap .code-text .token, +.projector.probe .val-resize.cursor-none .code-text .token, +.projector.probe .val-resize.cursor-outer-ap .code-text .token { filter: invert(1) brightness(10); } .projector.probe .val-resize.cursor-ap-lex .code-text .token { - color: var(--TYP); -} -.projector.probe .val-resize.cursor-outer-ap .code-text .token { - /* color: var(--TYP); */ - color: white; + color: var(--exp-ap-indicated); } .projector.probe .val-resize .code-text:hover { From 0325d22684f0052621c9d9bbb9fcbfd2335bd396 Mon Sep 17 00:00:00 2001 From: disconcision Date: Wed, 15 Jan 2025 15:35:55 -0500 Subject: [PATCH 272/281] pin aps for probe projector --- src/haz3lcore/zipper/projectors/ProbeProj.re | 96 ++++++++++++++++---- src/haz3lweb/www/img/noun-pinned-1560993.svg | 4 + src/haz3lweb/www/style.css | 1 - src/haz3lweb/www/style/projectors/probe.css | 52 ++++++++++- 4 files changed, 131 insertions(+), 22 deletions(-) create mode 100644 src/haz3lweb/www/img/noun-pinned-1560993.svg diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index fb182eda15..a5ae7d6781 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -19,7 +19,7 @@ type action = | PinAp(Id.t) | ChangeLength(Id.t, int) | Offset(int) - | ToggleShowAllVals; + | ToggleShowAllVals(int); let init = {display_lengths: Id.Map.empty, max_closures: 30, index_offset: 0}; @@ -177,7 +177,14 @@ let dynamic_cursor_cls = (info: info, closure: Dynamics.Probe.Closure.t) => }; let value_view = - (info: info, model, utility, local, closure: Dynamics.Probe.Closure.t) => { + ( + info: info, + model, + utility, + local, + closure: Dynamics.Probe.Closure.t, + index: int, + ) => { let val_pointerdown = (e: Js.t(Dom_html.pointerEvent)) => { let target = e##.target |> Js.Opt.get(_, _ => failwith("no target")); JsUtil.setPointerCapture(target, e##.pointerId) |> ignore; @@ -214,7 +221,7 @@ let value_view = @ dynamic_cursor_cls(info, closure) @ (Option.is_some(cur_ap_id(info)) ? ["ap"] : []), ), - Attr.on_double_click(_ => local(ToggleShowAllVals)), + Attr.on_double_click(_ => local(ToggleShowAllVals(index))), Attr.on_pointerdown(val_pointerdown), Attr.on_pointerup(val_pointerup), Attr.on_mousemove(val_mousemove), @@ -273,6 +280,7 @@ let closure_view = model: model, local, closure: Dynamics.Probe.Closure.t, + index: int, ) => div( ~attrs=[ @@ -280,7 +288,7 @@ let closure_view = ["closure"] @ (show_indicator(closure.stack) ? ["cursor"] : []), ), ], - [value_view(info, model, utility, local, closure)] + [value_view(info, model, utility, local, closure, index)] @ (is_var_ref(info) ? [] : [env_view(closure, utility)]), ); @@ -302,7 +310,7 @@ let nav_back = (di, model, local, left_cond) => Attr.classes( ["closures-header"] @ (left_cond ? ["disabled"] : []), ), - Attr.on_click(_ => left_cond ? Effect.Ignore : local(Offset(1))), + Attr.on_click(_ => left_cond ? Effect.Ignore : local(Offset(-1))), ], [Node.text("<")], ), @@ -317,7 +325,7 @@ let nav_forward = (di, model, local, right_cond) => Attr.classes( ["closures-tail"] @ (right_cond ? ["disabled"] : []), ), - Attr.on_click(_ => right_cond ? Effect.Ignore : local(Offset(-1))), + Attr.on_click(_ => right_cond ? Effect.Ignore : local(Offset(1))), ], [Node.text(">")], ), @@ -362,14 +370,35 @@ let group_closures = }; let closure_group_view = - (info, utility, model, local, closures: list(Dynamics.Probe.Closure.t)) => - group_closures(closures) - |> List.map(closures => + (info, utility, model, local, closures: list(Dynamics.Probe.Closure.t)) => { + let groups = group_closures(closures); + groups + |> List.mapi((i, closures) => Node.div( ~attrs=[Attr.classes(["closure-group"])], - List.map(closure_view(info, utility, model, local), closures), + { + let previous_lengths = + List.fold_left( + (acc, l) => acc + List.length(l), + 0, + List.filteri((idx, _) => idx < i, groups), + ); + List.mapi( + (j, closure) => + closure_view( + info, + utility, + model, + local, + closure, + previous_lengths + j, + ), + closures, + ); + }, ) ); +}; let offside_view = (model: model, ~info, ~local, ~parent as _, ~utility: utility) => { @@ -378,12 +407,34 @@ let offside_view = switch (info.dynamics) { | Some(di) => let frames = select_frames(model, di); + /* Filter pinned frames */ + let frames = + switch (State.s.pinned_ap) { + | Some(pinned_ap) => + frames + |> List.filter((closure: Dynamics.Probe.Closure.t) => + switch (closure.dyn_stack |> List.rev) { + | _ when Some(pinned_ap) == cur_ap_id(info) => true + | [frame, ..._] => frame.ap_id == pinned_ap + | [] => false + } + ) + | None => frames + }; let left_cond = model.index_offset >= List.length(di) - model.max_closures; let right_cond = model.index_offset <= 0; - nav_back(di, model, local, left_cond) - @ nav_forward(di, model, local, right_cond) - @ closure_group_view(info, utility, model, local, frames); + [ + div( + ~attrs=[Attr.classes(["nav-bar"])], + [ + div(nav_back(di, model, local, left_cond)), + div(nav_forward(di, model, local, right_cond)), + ], + ), + ] + @ closure_group_view(info, utility, model, local, frames) + @ (List.length(di) > model.max_closures ? [text("⋯")] : []); | _ => [] }, ); @@ -407,6 +458,10 @@ let num_closures_view = (info: info) => { ); }; +let pin_view = (info: info) => + State.s.pinned_ap != None && State.s.pinned_ap == cur_ap_id(info) + ? [div(~attrs=[Attr.classes(["pin"])], [])] : []; + let syntax_str = (info: info) => { let max_len = 30; let str = Printer.of_segment(~holes=None, [info.syntax]); @@ -426,18 +481,22 @@ let view = div( ~attrs=[ Attr.classes( - ["main"] @ (Option.is_some(cur_ap_id(info)) ? ["ap"] : []), + ["main"] + @ (Option.is_some(cur_ap_id(info)) ? ["ap"] : []) + @ (State.s.pinned_ap == cur_ap_id(info) ? ["pinned"] : []), ), - Attr.on_click(_ => { + Attr.on_double_click(_ => { //State.reset(); switch (State.s.pinned_ap) { - | Some(_) => State.s.pinned_ap = None + | Some(pinned_ap) when Some(pinned_ap) == cur_ap_id(info) => + State.s.pinned_ap = None + | Some(_) | None => State.s.pinned_ap = cur_ap_id(info) }; Effect.Ignore; }), ], - [syntax_view(info), icon, num_closures_view(info)], + [syntax_view(info), icon, num_closures_view(info)] @ pin_view(info), ); let update = (m: model, a: action) => { @@ -449,8 +508,9 @@ let update = (m: model, a: action) => { } else { m; } - | ToggleShowAllVals => { + | ToggleShowAllVals(offset) => { ...m, + index_offset: offset, max_closures: m.max_closures == 1 ? init.max_closures : 1, } | Offset(offset) => diff --git a/src/haz3lweb/www/img/noun-pinned-1560993.svg b/src/haz3lweb/www/img/noun-pinned-1560993.svg new file mode 100644 index 0000000000..90b3ce51bc --- /dev/null +++ b/src/haz3lweb/www/img/noun-pinned-1560993.svg @@ -0,0 +1,4 @@ + + + + diff --git a/src/haz3lweb/www/style.css b/src/haz3lweb/www/style.css index e38e08bfab..db77860488 100644 --- a/src/haz3lweb/www/style.css +++ b/src/haz3lweb/www/style.css @@ -121,7 +121,6 @@ select:hover { grid-column: 1 / span 2; display: flex; align-items: center; - gap: 1em; justify-content: space-between; align-items: stretch; background-color: var(--ui-bkg); diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index a8a9128447..b2aea024fb 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -64,7 +64,8 @@ .projector.probe .main.ap .icon { background-image: url(../../img/noun-telescope-7245201.svg); } -.projector.probe.indicated .main .icon { +.projector.probe.indicated .main .icon, +.projector.probe .main.ap.pinned .icon { filter: invert(1); } @@ -94,10 +95,33 @@ background-color: var(--num-closures); } .projector.probe.indicated.Right .num-closures { - background-color: var(--num-closures-indicated); + background-color: var(--num-closures-indicated) !important; right: -0.8em; top: -0.5em; } +.projector.probe:has(.main.ap.pinned) .num-closures { + background-color: var(--exp-ap-indicated); +} + +.projector.probe .pin { + position: absolute; + left: -0.5em; + top: -0.3em; + height: 0.8em; + width: 0.8em; + border-radius: 2em; + z-index: var(--code-emblems-z); + filter: invert(1); + background: url(../../img/noun-pinned-1560993.svg) oklch(0.65 0.18 137.67); + background-size: 70%; + background-position: center; + background-repeat: no-repeat; +} +.projector.probe.indicated.Left .pin { + background-color: oklch(0.8 0.18 201.83); + left: -0.61em; + top: -0.5em; +} .projector.probe .live-offside { display: flex; @@ -105,10 +129,25 @@ align-items: center; gap: 2px; } +.projector.probe.Exp .live-offside { + color: var(--exp-base); +} +.projector.probe.Pat .live-offside { + color: var(--pat-base); +} .projector.probe .live-offside:empty { display: none; } +.projector.probe .live-offside .nav-bar { + display: flex; + flex-direction: row; + align-items: center; + gap: 2px; + position: absolute; + left: -1.35em; +} + .projector.probe .closure-group { display: flex; gap: 2px; @@ -119,6 +158,7 @@ content: "•"; font-size: 0.4em; color: var(--exp-indicated); + margin: -1px; } .projector.probe .val-resize { @@ -138,8 +178,8 @@ border-bottom: 1px solid var(--exp-shadow); } .projector.probe.Pat .val-resize .code-text { - border-color: var(--pat-shadow); background-color: var(--pat-base); + border-bottom: 1px solid var(--pat-shadow); } .projector.probe .val-resize.cursor-lex .code-text { opacity: 100%; @@ -216,7 +256,13 @@ .projector.probe.indicated.Pat > svg { fill: var(--pat-indicated); } +.projector.probe:has(.main.ap.pinned) > svg { + fill: var(--exp-ap-indicated); +} +.projector.probe .main.ap.pinned { + color: white; +} .projector.probe.indicated .main { color: white; } From 9d4852fd2fbfbcaa507c7051d736a25d3b104b65 Mon Sep 17 00:00:00 2001 From: disconcision Date: Wed, 15 Jan 2025 22:14:37 -0500 Subject: [PATCH 273/281] clicking on probe projector now selects first cell. improved nav arrows somewhat --- src/haz3lcore/zipper/projectors/ProbeProj.re | 164 +++++++++---------- src/haz3lweb/www/style/projectors/probe.css | 30 ++-- 2 files changed, 97 insertions(+), 97 deletions(-) diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index a5ae7d6781..665d5badfc 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -292,46 +292,33 @@ let closure_view = @ (is_var_ref(info) ? [] : [env_view(closure, utility)]), ); -let select_frames = (model: model, vals) => { +let filter_frames_by_pin = + (info: info, frames: list(Dynamics.Probe.Closure.t)) => + //TODO(andrew): make this logic work more generally... + switch (State.s.pinned_ap) { + | Some(pinned_ap) => + frames + |> List.filter((closure: Dynamics.Probe.Closure.t) => + switch (closure.dyn_stack |> List.rev) { + | _ when Some(pinned_ap) == cur_ap_id(info) => true + | [frame, ..._] => frame.ap_id == pinned_ap + | [] => false + } + ) + | None => frames + }; + +let select_frames = (info: info, model: model, vals) => { switch (List.sort(comparor, vals)) { | [] => [] | _ => vals |> ListUtil.remove_first_n(model.index_offset) |> ListUtil.truncate(model.max_closures) + |> filter_frames_by_pin(info) }; }; -let nav_back = (di, model, local, left_cond) => - List.length(di) > model.max_closures - ? [ - Node.div( - ~attrs=[ - Attr.classes( - ["closures-header"] @ (left_cond ? ["disabled"] : []), - ), - Attr.on_click(_ => left_cond ? Effect.Ignore : local(Offset(-1))), - ], - [Node.text("<")], - ), - ] - : []; - -let nav_forward = (di, model, local, right_cond) => - List.length(di) > model.max_closures - ? [ - Node.div( - ~attrs=[ - Attr.classes( - ["closures-tail"] @ (right_cond ? ["disabled"] : []), - ), - Attr.on_click(_ => right_cond ? Effect.Ignore : local(Offset(1))), - ], - [Node.text(">")], - ), - ] - : []; - let group_by_predicate = /* Precondition: Items to be grouped are contigious in list */ (should_group: ('a, 'a) => bool, xs: list('a)): list(list('a)) => { @@ -372,27 +359,20 @@ let group_closures = let closure_group_view = (info, utility, model, local, closures: list(Dynamics.Probe.Closure.t)) => { let groups = group_closures(closures); + let closure_view = closure_view(info, utility, model, local); groups |> List.mapi((i, closures) => Node.div( ~attrs=[Attr.classes(["closure-group"])], { - let previous_lengths = + let lengths = List.fold_left( (acc, l) => acc + List.length(l), 0, List.filteri((idx, _) => idx < i, groups), ); List.mapi( - (j, closure) => - closure_view( - info, - utility, - model, - local, - closure, - previous_lengths + j, - ), + (j, closure) => closure_view(closure, lengths + j), closures, ); }, @@ -400,45 +380,49 @@ let closure_group_view = ); }; +let ellipsis_view = local => + div( + ~attrs=[ + Attr.classes(["ellipsis"]), + Attr.on_double_click(_ => {local(ToggleShowAllVals(0))}), + ], + [text("⋯")], + ); + +let nav_bar_view = (model, di, local) => { + let nav_arrow = (cond: bool, offset: int): Node.t => + Node.div( + ~attrs=[ + Attr.classes(["nav-arrow"] @ (cond ? ["disabled"] : [])), + Attr.on_click(_ => cond ? Effect.Ignore : local(Offset(offset))), + ], + [], + ); + let show_left = model.index_offset >= List.length(di) - model.max_closures; + let show_right = model.index_offset <= 0; + let view = + div( + ~attrs=[Attr.classes(["nav-bar"])], + [nav_arrow(show_left, 1), nav_arrow(show_right, -1)], + ); + List.length(di) > model.max_closures ? [view] : []; +}; + let offside_view = - (model: model, ~info, ~local, ~parent as _, ~utility: utility) => { + (model: model, ~info, ~local, ~parent as _, ~utility: utility) => Node.div( ~attrs=[Attr.classes(["live-offside"])], switch (info.dynamics) { | Some(di) => - let frames = select_frames(model, di); - /* Filter pinned frames */ - let frames = - switch (State.s.pinned_ap) { - | Some(pinned_ap) => - frames - |> List.filter((closure: Dynamics.Probe.Closure.t) => - switch (closure.dyn_stack |> List.rev) { - | _ when Some(pinned_ap) == cur_ap_id(info) => true - | [frame, ..._] => frame.ap_id == pinned_ap - | [] => false - } - ) - | None => frames - }; - let left_cond = - model.index_offset >= List.length(di) - model.max_closures; - let right_cond = model.index_offset <= 0; - [ - div( - ~attrs=[Attr.classes(["nav-bar"])], - [ - div(nav_back(di, model, local, left_cond)), - div(nav_forward(di, model, local, right_cond)), - ], - ), - ] + let frames = select_frames(info, model, di); + let ellipsis = + List.length(di) > model.max_closures ? [ellipsis_view(local)] : []; + nav_bar_view(model, di, local) @ closure_group_view(info, utility, model, local, frames) - @ (List.length(di) > model.max_closures ? [text("⋯")] : []); + @ ellipsis; | _ => [] }, ); -}; let num_closures = (info: info) => switch (info.dynamics) { @@ -477,7 +461,30 @@ let placeholder = (_m, info) => let icon = div(~attrs=[Attr.classes(["icon"])], []); let view = - (_: model, ~info, ~local as _, ~parent as _, ~utility as _: utility) => + (_: model, ~info, ~local as _, ~parent as _, ~utility as _: utility) => { + let on_double_click = _ => { + //State.reset(); + switch (State.s.pinned_ap) { + | Some(pinned_ap) when Some(pinned_ap) == cur_ap_id(info) => + State.s.pinned_ap = None + | Some(_) + | None => State.s.pinned_ap = cur_ap_id(info) + }; + Effect.Ignore; + }; + + let on_pointerdown = _ => { + switch (info.dynamics) { + | Some(di) => + switch (di) { + | [first_closure, ..._] => State.capture(info, first_closure) + | [] => () + } + | None => () + }; + Effect.Ignore; + }; + div( ~attrs=[ Attr.classes( @@ -485,19 +492,12 @@ let view = @ (Option.is_some(cur_ap_id(info)) ? ["ap"] : []) @ (State.s.pinned_ap == cur_ap_id(info) ? ["pinned"] : []), ), - Attr.on_double_click(_ => { - //State.reset(); - switch (State.s.pinned_ap) { - | Some(pinned_ap) when Some(pinned_ap) == cur_ap_id(info) => - State.s.pinned_ap = None - | Some(_) - | None => State.s.pinned_ap = cur_ap_id(info) - }; - Effect.Ignore; - }), + Attr.on_double_click(on_double_click), + Attr.on_pointerdown(on_pointerdown), ], [syntax_view(info), icon, num_closures_view(info)] @ pin_view(info), ); +}; let update = (m: model, a: action) => { //print_endline("update: action:" ++ show_action(a)); diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index b2aea024fb..1b2750f8bb 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -129,12 +129,6 @@ align-items: center; gap: 2px; } -.projector.probe.Exp .live-offside { - color: var(--exp-base); -} -.projector.probe.Pat .live-offside { - color: var(--pat-base); -} .projector.probe .live-offside:empty { display: none; } @@ -148,6 +142,16 @@ left: -1.35em; } +.projector.probe .live-offside .ellipsis { + cursor: pointer; +} +.projector.probe.Exp .live-offside .ellipsis { + color: var(--exp-base); +} +.projector.probe.Pat .live-offside .ellipsis { + color: var(--pat-base); +} + .projector.probe .closure-group { display: flex; gap: 2px; @@ -274,8 +278,7 @@ display: none; } -.projector.probe .closures-header, -.projector.probe .closures-tail { +.projector.probe .nav-arrow { width: 10px; height: 13px; cursor: pointer; @@ -285,22 +288,19 @@ color: var(--NONE); filter: invert(1) brightness(0.5) sepia(1) hue-rotate(61deg); } -.projector.probe .closures-tail { +.projector.probe .nav-arrow:last-child { transform: rotate(180deg); } -.projector.probe:not(.indicated) .closures-header, -.projector.probe:not(.indicated) .closures-tail { +.projector.probe:not(.indicated) .nav-arrow { pointer-events: none; opacity: 0% !important; } -.projector.probe .closures-header.disabled, -.projector.probe .closures-tail.disabled { +.projector.probe .nav-arrow.disabled { opacity: 15%; } -.projector.probe .closures-header:hover, -.projector.probe .closures-tail:hover { +.projector.probe .nav-arrow:hover { filter: brightness(1.05) saturate(1.05); } From e592948bc2c0b0110b26176dc9bd160e3138c913 Mon Sep 17 00:00:00 2001 From: disconcision Date: Wed, 15 Jan 2025 22:44:46 -0500 Subject: [PATCH 274/281] projector update functions now have access to the semantic info pack --- src/haz3lcore/zipper/ProjectorBase.re | 20 +++++++++---------- .../zipper/projectors/CheckboxProj.re | 4 ++-- src/haz3lcore/zipper/projectors/FoldProj.re | 4 ++-- src/haz3lcore/zipper/projectors/InfoProj.re | 4 ++-- src/haz3lcore/zipper/projectors/ProbeProj.re | 9 ++++----- .../zipper/projectors/SliderFProj.re | 4 ++-- src/haz3lcore/zipper/projectors/SliderProj.re | 4 ++-- .../zipper/projectors/TextAreaProj.re | 4 ++-- src/haz3lweb/app/common/ProjectorView.re | 9 +++++---- 9 files changed, 31 insertions(+), 31 deletions(-) diff --git a/src/haz3lcore/zipper/ProjectorBase.re b/src/haz3lcore/zipper/ProjectorBase.re index 886376f10d..e0bb5c68d1 100644 --- a/src/haz3lcore/zipper/ProjectorBase.re +++ b/src/haz3lcore/zipper/ProjectorBase.re @@ -38,7 +38,7 @@ type utility = { font_metrics: FontMetrics.t, /* Non-interactive view for segments, included here * because of cyclic dependency issues*/ - view: (Sort.t, Base.segment) => Node.t, + view_seg: (Sort.t, Base.segment) => Node.t, /* Convert an expression to a segment, included here * because of cyclic dependency issues*/ exp_to_seg: Exp.t => Base.segment, @@ -97,7 +97,7 @@ module type Projector = { let view: ( model, - ~info: info, + info, ~local: action => Ui_effect.t(unit), ~parent: external_action => Ui_effect.t(unit), ~utility: utility @@ -109,7 +109,7 @@ module type Projector = { option( ( model, - ~info: info, + info, ~local: action => Ui_effect.t(unit), ~parent: external_action => Ui_effect.t(unit), ~utility: utility @@ -125,7 +125,7 @@ module type Projector = { * in sync with each other. */ let placeholder: (model, info) => ProjectorShape.t; /* Update the local projector model given an action */ - let update: (model, action) => model; + let update: (model, info, action) => model; /* Does whatever needs to be done to give a projector * keyboard focus. Right now this is only for side * effects but could be extended in the future to @@ -154,20 +154,20 @@ module Cook = (C: Projector) : Cooked => { let can_project = C.can_project; let can_focus = C.can_focus; let dynamics = C.dynamics; - let view = (m, ~info, ~local, ~parent, ~utility) => + let view = (m, info, ~local, ~parent, ~utility) => C.view( deserialize_m(m), - ~info, + info, ~local=a => local(serialize_a(a)), ~parent, ~utility, ); let offside_view = Option.map( - (f, m, ~info, ~local, ~parent, ~utility) => + (f, m, info, ~local, ~parent, ~utility) => f( deserialize_m(m), - ~info, + info, ~local=a => local(serialize_a(a)), ~parent, ~utility, @@ -176,8 +176,8 @@ module Cook = (C: Projector) : Cooked => { ); let placeholder = m => m |> Sexplib.Sexp.of_string |> C.model_of_sexp |> C.placeholder; - let update = (m, a) => - C.update(m |> deserialize_m, a |> deserialize_a) |> serialize_m; + let update = (m, i, a) => + C.update(m |> deserialize_m, i, a |> deserialize_a) |> serialize_m; let focus = C.focus; }; diff --git a/src/haz3lcore/zipper/projectors/CheckboxProj.re b/src/haz3lcore/zipper/projectors/CheckboxProj.re index 08fcefc19f..4517ac165c 100644 --- a/src/haz3lcore/zipper/projectors/CheckboxProj.re +++ b/src/haz3lcore/zipper/projectors/CheckboxProj.re @@ -27,7 +27,7 @@ let toggle = (piece: Piece.t) => put(!get(piece)); let view = ( _, - ~info, + info, ~local as _, ~parent: external_action => Ui_effect.t(unit), ~utility as _, @@ -54,7 +54,7 @@ module M: Projector = { let can_focus = false; let dynamics = false; let placeholder = (_, _) => ProjectorShape.inline(2); - let update = (model, _) => model; + let update = (model, _, _) => model; let view = view; let offside_view = Option.None; let focus = _ => (); diff --git a/src/haz3lcore/zipper/projectors/FoldProj.re b/src/haz3lcore/zipper/projectors/FoldProj.re index d05f771239..ece0eaec80 100644 --- a/src/haz3lcore/zipper/projectors/FoldProj.re +++ b/src/haz3lcore/zipper/projectors/FoldProj.re @@ -20,8 +20,8 @@ module M: Projector = { let dynamics = false; let placeholder = (m, _) => ProjectorShape.inline(m.text == "⋱" ? 2 : m.text |> String.length); - let update = (m, _) => m; - let view = (m: model, ~info as _, ~local as _, ~parent, ~utility as _) => + let update = (m, _, _) => m; + let view = (m: model, _, ~local as _, ~parent, ~utility as _) => div( ~attrs=[Attr.on_double_click(_ => parent(Remove))], [text(m.text)], diff --git a/src/haz3lcore/zipper/projectors/InfoProj.re b/src/haz3lcore/zipper/projectors/InfoProj.re index 844976a006..0882dea3bf 100644 --- a/src/haz3lcore/zipper/projectors/InfoProj.re +++ b/src/haz3lcore/zipper/projectors/InfoProj.re @@ -73,13 +73,13 @@ module M: Projector = { (display(model, info.statics) |> String.length) + 5, ); - let update = (model, a: action) => + let update = (model, _, a: action) => switch (a, model) { | (ToggleDisplay, Expected) => Self | (ToggleDisplay, Self) => Expected }; - let view = (model, ~info, ~local, ~parent as _, ~utility as _) => + let view = (model, info, ~local, ~parent as _, ~utility as _) => div( ~attrs=[ Attr.classes(["info", "code"]), diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index 665d5badfc..d7951a95b6 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -127,7 +127,7 @@ let seg_view = (utility, available, seg) => |> Abbreviate.abbreviate_exp(~available) |> fst |> utility.exp_to_seg - |> utility.view(Exp); + |> utility.view_seg(Exp); let get_goal = (utility: utility, e: Js.t(Dom_html.mouseEvent)) => FontMetrics.get_goal( @@ -409,7 +409,7 @@ let nav_bar_view = (model, di, local) => { }; let offside_view = - (model: model, ~info, ~local, ~parent as _, ~utility: utility) => + (model: model, info, ~local, ~parent as _, ~utility: utility) => Node.div( ~attrs=[Attr.classes(["live-offside"])], switch (info.dynamics) { @@ -460,8 +460,7 @@ let placeholder = (_m, info) => let icon = div(~attrs=[Attr.classes(["icon"])], []); -let view = - (_: model, ~info, ~local as _, ~parent as _, ~utility as _: utility) => { +let view = (_: model, info, ~local as _, ~parent as _, ~utility as _: utility) => { let on_double_click = _ => { //State.reset(); switch (State.s.pinned_ap) { @@ -499,7 +498,7 @@ let view = ); }; -let update = (m: model, a: action) => { +let update = (m: model, _info: info, a: action) => { //print_endline("update: action:" ++ show_action(a)); switch (a) { | ChangeLength(id, len) => diff --git a/src/haz3lcore/zipper/projectors/SliderFProj.re b/src/haz3lcore/zipper/projectors/SliderFProj.re index 006c9d9b33..83f989ceb6 100644 --- a/src/haz3lcore/zipper/projectors/SliderFProj.re +++ b/src/haz3lcore/zipper/projectors/SliderFProj.re @@ -26,11 +26,11 @@ module M: Projector = { let can_focus = false; let dynamics = false; let placeholder = (_, _) => ProjectorShape.inline(10); - let update = (model, _) => model; + let update = (model, _, _) => model; let view = ( _, - ~info, + info, ~local as _, ~parent: external_action => Ui_effect.t(unit), ~utility as _, diff --git a/src/haz3lcore/zipper/projectors/SliderProj.re b/src/haz3lcore/zipper/projectors/SliderProj.re index f89095d2cb..54b1d264ba 100644 --- a/src/haz3lcore/zipper/projectors/SliderProj.re +++ b/src/haz3lcore/zipper/projectors/SliderProj.re @@ -23,11 +23,11 @@ module M: Projector = { let can_focus = false; let dynamics = false; let placeholder = (_, _) => ProjectorShape.inline(10); - let update = (model, _) => model; + let update = (model, _, _) => model; let view = ( _, - ~info, + info, ~local as _, ~parent: external_action => Ui_effect.t(unit), ~utility as _, diff --git a/src/haz3lcore/zipper/projectors/TextAreaProj.re b/src/haz3lcore/zipper/projectors/TextAreaProj.re index 3006515a20..8ebeb83839 100644 --- a/src/haz3lcore/zipper/projectors/TextAreaProj.re +++ b/src/haz3lcore/zipper/projectors/TextAreaProj.re @@ -77,7 +77,7 @@ let textarea = [], ); -let view = (_, ~info, ~local as _, ~parent, ~utility as _) => { +let view = (_, info, ~local as _, ~parent, ~utility as _) => { let text = info.syntax |> get |> Form.strip_quotes; Node.div( ~attrs=[Attr.classes(["wrapper"])], @@ -107,7 +107,7 @@ module M: Projector = { horizontal: 2 + StringUtil.max_line_width(str), }; }; - let update = (model, _) => model; + let update = (model, _, _) => model; let view = view; let offside_view = Option.None; let focus = ((id: Id.t, d: option(Direction.t))) => { diff --git a/src/haz3lweb/app/common/ProjectorView.re b/src/haz3lweb/app/common/ProjectorView.re index 78c7b5b723..42c0028182 100644 --- a/src/haz3lweb/app/common/ProjectorView.re +++ b/src/haz3lweb/app/common/ProjectorView.re @@ -127,7 +127,7 @@ let offside_pos = offside_offset => let collate_utility = (globals: Globals.t): ProjectorBase.utility => { { font_metrics: globals.font_metrics, - view: (sort, seg) => + view_seg: (sort, seg) => CodeViewable.view_segment( ~globals, ~sort, @@ -175,7 +175,8 @@ let setup_view = let utility = collate_utility(globals); let (module P) = to_module(p.kind); let parent = a => inject(Project(handle(id, a))); - let local = a => inject(Project(SetModel(id, P.update(p.model, a)))); + let local = a => + inject(Project(SetModel(id, P.update(p.model, info, a)))); let offside_pos = offside_pos( offside( @@ -190,7 +191,7 @@ let setup_view = v => div( ~attrs=[offside_pos], - [v(p.model, ~info, ~local, ~parent, ~utility)], + [v(p.model, info, ~local, ~parent, ~utility)], ), P.offside_view, ); @@ -203,7 +204,7 @@ let setup_view = ~selected=List.mem(id, cached_syntax.selection_ids), p, offside_view, - P.view(p.model, ~info, ~local, ~parent, ~utility), + P.view(p.model, info, ~local, ~parent, ~utility), ); }; From c2668c9347882a622333633e2ca4eff2b63c69a7 Mon Sep 17 00:00:00 2001 From: disconcision Date: Thu, 16 Jan 2025 18:45:13 -0500 Subject: [PATCH 275/281] add icon license readme. probe cleanup --- licenses/Icons.md | 1 + src/haz3lcore/zipper/Projector.re | 5 +- src/haz3lcore/zipper/ProjectorBase.re | 36 +- src/haz3lcore/zipper/projectors/ProbeProj.re | 353 ++++++++++--------- src/haz3lweb/www/style/projectors/probe.css | 6 + src/util/ListUtil.re | 4 + 6 files changed, 221 insertions(+), 184 deletions(-) create mode 100644 licenses/Icons.md diff --git a/licenses/Icons.md b/licenses/Icons.md new file mode 100644 index 0000000000..0ec567f4eb --- /dev/null +++ b/licenses/Icons.md @@ -0,0 +1 @@ +The icons used in Hazel, including the Hazel icon, are from The Noun Project (https://thenounproject.com/) under the Icon Pro license (https://thenounproject.com/legal/terms-of-use/#icon-licenses). diff --git a/src/haz3lcore/zipper/Projector.re b/src/haz3lcore/zipper/Projector.re index a01375125a..aceb511219 100644 --- a/src/haz3lcore/zipper/Projector.re +++ b/src/haz3lcore/zipper/Projector.re @@ -19,7 +19,7 @@ let to_module = (kind: Base.kind): (module Cooked) => let minimum_projection_condition = (syntax: syntax): bool => Piece.is_convex(syntax); -let init = (kind: t, syntax: syntax): syntax => { +let init = (kind: Base.kind, syntax: syntax): syntax => { /* We set the projector id equal to the Piece id for convienence * including cursor-info association. We maintain this invariant * when we update a projector's contained syntax */ @@ -30,7 +30,8 @@ let init = (kind: t, syntax: syntax): syntax => { }; }; -let init_from_str = (kind: t, syntax: syntax, model_str: string): syntax => { +let init_from_str = + (kind: Base.kind, syntax: syntax, model_str: string): syntax => { let (module P) = to_module(kind); switch (P.can_project(syntax) && minimum_projection_condition(syntax)) { | false => syntax diff --git a/src/haz3lcore/zipper/ProjectorBase.re b/src/haz3lcore/zipper/ProjectorBase.re index e0bb5c68d1..29f67c6fc9 100644 --- a/src/haz3lcore/zipper/ProjectorBase.re +++ b/src/haz3lcore/zipper/ProjectorBase.re @@ -1,8 +1,14 @@ open Util; open Virtual_dom.Vdom; -[@deriving (show({with_path: false}), sexp, yojson)] -type t = Base.kind; +/* This determines the API for projectors, GUIs which + * can replace part of the program syntax, and perform + * actions which changes that underlying syntax, as well + * as mainting their own custom state. The comments below + * detail the procedure of defining a new projector. + * + * See the zipper/projectors/ folder for the implementations + * of currently available projectors */ /* The type of syntax which a projector can replace. * Right now projectors can replace a single piece */ @@ -15,22 +21,32 @@ type external_action = | Escape(Util.Direction.t) /* Pass focus to parent editor */ | SetSyntax(syntax); /* Set underlying syntax */ -/* External info fed to all projectors. Eventually - * dynamic information will be added here. Projector - * position and dimensions in base editor could be - * added here if needed */ +/* External info proivded to all projectors */ [@deriving (show({with_path: false}), sexp, yojson)] type info = { + /* The id of the projector, equal to the id of the root + * term of the syntax, provided directly here for convenience. + * This is mostly intended to be used as a persistent unique + * identifier to allow individual projectors to distiguish + * their DOM nodes. */ id: Id.t, + /* The syntax underlying the projector. Currently this + * is a single piece representing a complete term, but + * this may be relaxed in the future. */ syntax, + /* Static information about the syntax including type + * information. Statics may be disabled by the user; + * this case (None) must be handled by projector authors */ statics: option(Statics.Info.t), + /* Dynamic information about the syntax including + * live values of the syntax. Dynamics may be + * disabled by the user; this case (None) must be + * handled by projector authors */ dynamics: option(Dynamics.Info.t), }; /* Utility functions/values for to projector views. - * These should be considered unstable/experimental - * features which have yet to be integrated into the - * projector API in a disciplined way */ + * These should be considered unstable/experimental */ [@deriving (show({with_path: false}), sexp, yojson)] type utility = { /* The current font metrics for the editor, usable @@ -184,7 +200,7 @@ module Cook = (C: Projector) : Cooked => { /* Projectors currently are all convex */ let shapes = (_: Base.projector) => Nib.Shape.(Convex, Convex); -/* Projectors currently have a unique molding */ +/* Projectors currently have a fixed molding */ let mold_of = (p, sort: Sort.t): Mold.t => { let (l, r) = shapes(p); { diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index d7951a95b6..83a8610102 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -4,6 +4,9 @@ open Virtual_dom.Vdom; open Node; open Js_of_ocaml; +[@deriving (show({with_path: false}), sexp, yojson)] +type closure = Dynamics.Probe.Closure.t; + [@deriving (show({with_path: false}), sexp, yojson)] type model = { /* Max col length for value display, indexed by closure id */ @@ -29,32 +32,25 @@ let model_of_sexp = (sexp): model => | x => x }; -let display_length = (model: model, id: Id.t): int => - Id.Map.find_opt(id, model.display_lengths) |> Option.value(~default=12); - -module Debug = { - let of_id = (id: Id.t) => String.sub(Id.to_string(id), 0, 3); - - let stack = stack => - stack - |> List.rev - |> List.map(({env_id, ap_id}: Probe.frame) => - "" ++ of_id(env_id) ++ " : " ++ of_id(ap_id) - ) - |> String.concat("\n"); +/* Remove opaque values like function literals */ +let rm_opaques: + list(Dynamics.Probe.Env.entry) => list(Dynamics.Probe.Env.entry) = + List.filter_map((en: Dynamics.Probe.Env.entry) => + switch (en.value) { + | Opaque => None + | Val(_) => Some(en) + } + ); - let str = (closure: Dynamics.Probe.Closure.t) => - "closure_id: " - ++ of_id(closure.closure_id) - ++ "\nenv_id: " - ++ of_id(closure.env_id) - ++ "\ndyn_stack:\n" - ++ stack(closure.dyn_stack) - ++ "\nstack:\n" - ++ stack(closure.stack); -}; +/* Is the underlying syntax a variable reference? */ +let is_var_ref = (info: info): bool => + switch (info.statics) { + | Some(InfoExp({term: {term: Var(_), _}, _})) + | Some(InfoPat({term: {term: Var(_), _}, _})) => true + | _ => false + }; -let cur_ap_id = (info: info) => +let cur_ap_id = (info: info): option(Id.t) => switch (info.statics) { | Some(InfoExp({term: {term: Ap(_), _} as ap, _})) => Some(Term.Exp.rep_id(ap)) @@ -63,13 +59,15 @@ let cur_ap_id = (info: info) => | _ => None }; -let cur_outer_ap_id = (_info: info, dyn_stack: Probe.stack) => +let cur_outer_ap_id = (_info: info, dyn_stack: Probe.stack): option(Id.t) => switch (dyn_stack) { | [frame, ..._] => Some(frame.ap_id) | _ => None }; module State = { + /* Manages shared state between probes */ + type t = { mutable pinned_ap: option(Id.t), mutable env_cursor: list(Id.t), @@ -94,7 +92,7 @@ module State = { s.outer_ap_id = None; }; - let capture = (info: info, closure: Dynamics.Probe.Closure.t) => { + let capture = (info: info, closure: closure) => { s.env_cursor = Probe.env_stack(closure.stack); s.dyn_env_cursor = closure.dyn_stack; s.cur_ap = cur_ap_id(info); @@ -102,26 +100,128 @@ module State = { }; }; -let comparor = (a: Dynamics.Probe.Closure.t, b: Dynamics.Probe.Closure.t) => { - compare( - ListUtil.common_suffix_length( - State.s.env_cursor, - Probe.env_stack(b.stack), - ), - ListUtil.common_suffix_length( - State.s.env_cursor, - Probe.env_stack(a.stack), - ), - ); +module Closures = { + let num = (info: info): int => + switch (info.dynamics) { + | Some(di) => List.length(di) + | None => 0 + }; + + let filter_frames_by_pin = + (info: info, frames: list(closure)): list(closure) => + //TODO(andrew): make this logic work more generally... + switch (State.s.pinned_ap) { + | Some(pinned_ap) => + frames + |> List.filter((closure: closure) => + switch (closure.dyn_stack |> List.rev) { + | _ when Some(pinned_ap) == cur_ap_id(info) => true + | [frame, ..._] => frame.ap_id == pinned_ap + | [] => false + } + ) + | None => frames + }; + + let comparor = (a: closure, b: closure): int => { + compare( + ListUtil.common_suffix_length( + State.s.env_cursor, + Probe.env_stack(b.stack), + ), + ListUtil.common_suffix_length( + State.s.env_cursor, + Probe.env_stack(a.stack), + ), + ); + }; + + let select_frames = + (info: info, model: model, closures: list(closure)): list(closure) => { + switch (List.sort(comparor, closures)) { + | [] => [] + | _ => + closures + |> filter_frames_by_pin(info) + |> ListUtil.slice(model.index_offset, model.max_closures) + }; + }; + + let group_by_predicate = + /* Precondition: Items to be grouped are contigious in list */ + (should_group: ('a, 'a) => bool, xs: list('a)): list(list('a)) => { + List.fold_left( + (acc: list(list('a)), item: 'a) => { + switch (acc) { + | [] => [[item]] + | [[rep, ..._] as first, ...init] when should_group(rep, item) => [ + first @ [item], + ...init, + ] + | _ => [[item]] @ acc + } + }, + [], + xs, + ); + }; + + let is_same_call = ((_, c1: closure), (_, c2: closure)): bool => { + switch (List.rev(c2.dyn_stack), List.rev(c1.dyn_stack)) { + | ([], _) + | (_, []) => false + | ([f1, ..._], [f2, ..._]) => f1 == f2 + }; + }; + + let group = + (closures: list((int, closure))): list(list((int, closure))) => { + let grouped = + closures |> group_by_predicate(is_same_call) |> List.map(List.rev); + /* Flatten if all groups are singletons */ + List.for_all(group => List.length(group) == 1, grouped) + ? [List.concat(grouped)] : grouped; + }; + + let collate = + (info: info, model: model, di: list(closure)) + : list(list((int, closure))) => { + let closures = select_frames(info, model, di); + let numbered_closures = + List.mapi((i, c) => (List.length(closures) - i - 1, c), closures); + group(numbered_closures); + }; }; -let depth_in_cur_ap_stack = (dyn_stack): option(int) => +module Debug = { + let of_id = (id: Id.t): string => String.sub(Id.to_string(id), 0, 3); + + let stack = (stack: Probe.stack): string => + stack + |> List.rev + |> List.map(({env_id, ap_id}: Probe.frame) => + "" ++ of_id(env_id) ++ " : " ++ of_id(ap_id) + ) + |> String.concat("\n"); + + let str = (closure: closure): string => + "closure_id: " + ++ of_id(closure.closure_id) + ++ "\nenv_id: " + ++ of_id(closure.env_id) + ++ "\ndyn_stack:\n" + ++ stack(closure.dyn_stack) + ++ "\nstack:\n" + ++ stack(closure.stack); +}; + +let depth_in_cur_ap_stack = (dyn_stack: list(Probe.frame)): option(int) => List.find_index( ({ap_id, _}: Probe.frame) => Some(ap_id) == State.s.cur_ap, dyn_stack, ); -let seg_view = (utility, available, seg) => +let seg_view = (utility: utility, available: int, seg: Exp.t): Node.t => seg |> DHExp.strip_casts |> Abbreviate.abbreviate_exp(~available) @@ -129,7 +229,7 @@ let seg_view = (utility, available, seg) => |> utility.exp_to_seg |> utility.view_seg(Exp); -let get_goal = (utility: utility, e: Js.t(Dom_html.mouseEvent)) => +let get_goal = (utility: utility, e: Js.t(Dom_html.mouseEvent)): Point.t => FontMetrics.get_goal( ~font_metrics=utility.font_metrics, e##.currentTarget @@ -139,9 +239,7 @@ let get_goal = (utility: utility, e: Js.t(Dom_html.mouseEvent)) => e |> Js.Unsafe.coerce, ); -let mousedown: ref(option(Js.t(Dom_html.element))) = ref(Option.None); - -let on_outer_ap = (info: info, closure: Dynamics.Probe.Closure.t): bool => +let on_outer_ap = (info: info, closure: closure): bool => switch (cur_ap_id(info), State.s.outer_ap_id) { | (Some(ap_id), Some(outer_ap_id)) => ap_id == outer_ap_id @@ -154,7 +252,7 @@ let on_outer_ap = (info: info, closure: Dynamics.Probe.Closure.t): bool => | _ => false }; -let show_indicator = stack => { +let show_indicator = (stack: Probe.stack): bool => { let local = Probe.env_stack(stack); State.s.env_cursor == [] && local == [] @@ -165,7 +263,7 @@ let show_indicator = stack => { ); }; -let dynamic_cursor_cls = (info: info, closure: Dynamics.Probe.Closure.t) => +let dynamic_cursor_cls = (info: info, closure: closure): list(string) => switch (depth_in_cur_ap_stack(closure.dyn_stack)) { | _ when on_outer_ap(info, closure) => ["cursor-outer-ap"] | Some(depth) @@ -176,13 +274,18 @@ let dynamic_cursor_cls = (info: info, closure: Dynamics.Probe.Closure.t) => | None => ["cursor-none"] }; +let display_length = (model: model, id: Id.t): int => + Id.Map.find_opt(id, model.display_lengths) |> Option.value(~default=12); + +let mousedown: ref(option(Js.t(Dom_html.element))) = ref(Option.None); + let value_view = ( info: info, - model, - utility, + model: model, + utility: utility, local, - closure: Dynamics.Probe.Closure.t, + closure: closure, index: int, ) => { let val_pointerdown = (e: Js.t(Dom_html.pointerEvent)) => { @@ -236,7 +339,7 @@ let value_view = ); }; -let env_val = (utility: utility, en: Dynamics.Probe.Env.entry) => { +let env_val = (utility: utility, en: Dynamics.Probe.Env.entry): Node.t => { Node.div( ~attrs=[Attr.classes(["live-env-entry"])], [ @@ -249,25 +352,7 @@ let env_val = (utility: utility, en: Dynamics.Probe.Env.entry) => { ); }; -/* Remove opaque values like function literals */ -let rm_opaques: - list(Dynamics.Probe.Env.entry) => list(Dynamics.Probe.Env.entry) = - List.filter_map((en: Dynamics.Probe.Env.entry) => - switch (en.value) { - | Opaque => None - | Val(_) => Some(en) - } - ); - -/* Is the underlying syntax a variable reference? */ -let is_var_ref = (info: info): bool => - switch (info.statics) { - | Some(InfoExp({term: {term: Var(_), _}, _})) - | Some(InfoPat({term: {term: Var(_), _}, _})) => true - | _ => false - }; - -let env_view = (closure: Dynamics.Probe.Closure.t, utility: utility): Node.t => +let env_view = (closure: closure, utility: utility): Node.t => Node.div( ~attrs=[Attr.classes(["live-env"])], closure.env |> ListUtil.dedup |> rm_opaques |> List.map(env_val(utility)), @@ -275,12 +360,11 @@ let env_view = (closure: Dynamics.Probe.Closure.t, utility: utility): Node.t => let closure_view = ( - info, + info: info, utility: utility, model: model, local, - closure: Dynamics.Probe.Closure.t, - index: int, + (index: int, closure: closure), ) => div( ~attrs=[ @@ -292,95 +376,22 @@ let closure_view = @ (is_var_ref(info) ? [] : [env_view(closure, utility)]), ); -let filter_frames_by_pin = - (info: info, frames: list(Dynamics.Probe.Closure.t)) => - //TODO(andrew): make this logic work more generally... - switch (State.s.pinned_ap) { - | Some(pinned_ap) => - frames - |> List.filter((closure: Dynamics.Probe.Closure.t) => - switch (closure.dyn_stack |> List.rev) { - | _ when Some(pinned_ap) == cur_ap_id(info) => true - | [frame, ..._] => frame.ap_id == pinned_ap - | [] => false - } - ) - | None => frames - }; - -let select_frames = (info: info, model: model, vals) => { - switch (List.sort(comparor, vals)) { - | [] => [] - | _ => - vals - |> ListUtil.remove_first_n(model.index_offset) - |> ListUtil.truncate(model.max_closures) - |> filter_frames_by_pin(info) - }; -}; - -let group_by_predicate = - /* Precondition: Items to be grouped are contigious in list */ - (should_group: ('a, 'a) => bool, xs: list('a)): list(list('a)) => { - List.fold_left( - (acc: list(list('a)), item: 'a) => { - switch (acc) { - | [] => [[item]] - | [[rep, ..._] as first, ...init] when should_group(rep, item) => [ - first @ [item], - ...init, - ] - | _ => [[item]] @ acc - } - }, - [], - xs, - ); -}; - -let group_closures = - (closures: list(Dynamics.Probe.Closure.t)) - : list(list(Dynamics.Probe.Closure.t)) => { - let is_same_call = - (c1: Dynamics.Probe.Closure.t, c2: Dynamics.Probe.Closure.t) => { - switch (List.rev(c2.dyn_stack), List.rev(c1.dyn_stack)) { - | ([], _) - | (_, []) => false - | ([f1, ..._], [f2, ..._]) => f1 == f2 - }; - }; - let grouped = - closures |> group_by_predicate(is_same_call) |> List.map(List.rev); - /* Flatten if all groups are singletons */ - List.for_all(group => List.length(group) == 1, grouped) - ? [List.concat(grouped)] : grouped; -}; - let closure_group_view = - (info, utility, model, local, closures: list(Dynamics.Probe.Closure.t)) => { - let groups = group_closures(closures); - let closure_view = closure_view(info, utility, model, local); - groups - |> List.mapi((i, closures) => - Node.div( - ~attrs=[Attr.classes(["closure-group"])], - { - let lengths = - List.fold_left( - (acc, l) => acc + List.length(l), - 0, - List.filteri((idx, _) => idx < i, groups), - ); - List.mapi( - (j, closure) => closure_view(closure, lengths + j), - closures, - ); - }, - ) - ); + (info, utility, model, local, groups: list(list((int, closure)))) => { + let group_views = + List.map( + closures => + Node.div( + ~attrs=[Attr.classes(["closure-group"])], + List.map(closure_view(info, utility, model, local), closures), + ), + groups, + ); + group_views == [] + ? [] : [div(~attrs=[Attr.classes(["closure-groups"])], group_views)]; }; -let ellipsis_view = local => +let ellipsis_view = (local): Node.t => div( ~attrs=[ Attr.classes(["ellipsis"]), @@ -389,7 +400,7 @@ let ellipsis_view = local => [text("⋯")], ); -let nav_bar_view = (model, di, local) => { +let nav_bar_view = (model: model, di: list(closure), local) => { let nav_arrow = (cond: bool, offset: int): Node.t => Node.div( ~attrs=[ @@ -408,30 +419,23 @@ let nav_bar_view = (model, di, local) => { List.length(di) > model.max_closures ? [view] : []; }; -let offside_view = - (model: model, info, ~local, ~parent as _, ~utility: utility) => +let offside_view = (model: model, info: info, local, utility: utility) => Node.div( ~attrs=[Attr.classes(["live-offside"])], switch (info.dynamics) { | Some(di) => - let frames = select_frames(info, model, di); + let groups = Closures.collate(info, model, di); let ellipsis = List.length(di) > model.max_closures ? [ellipsis_view(local)] : []; nav_bar_view(model, di, local) - @ closure_group_view(info, utility, model, local, frames) + @ closure_group_view(info, utility, model, local, groups) @ ellipsis; | _ => [] }, ); -let num_closures = (info: info) => - switch (info.dynamics) { - | Some(di) => List.length(di) - | None => 0 - }; - let num_closures_view = (info: info) => { - let num_closures = num_closures(info); + let num_closures = Closures.num(info); let description = num_closures < 1000 ? string_of_int(num_closures) : "1k+"; div( ~attrs=[ @@ -460,7 +464,7 @@ let placeholder = (_m, info) => let icon = div(~attrs=[Attr.classes(["icon"])], []); -let view = (_: model, info, ~local as _, ~parent as _, ~utility as _: utility) => { +let view = (info: info): Node.t => { let on_double_click = _ => { //State.reset(); switch (State.s.pinned_ap) { @@ -541,7 +545,12 @@ module M: Projector = { let dynamics = true; let placeholder = placeholder; let update = update; - let view = view; - let offside_view = Some(offside_view); + let view = (_model, info, ~local as _, ~parent as _, ~utility as _) => + view(info); + let offside_view = + Some( + (model, info, ~local, ~parent as _, ~utility) => + offside_view(model, info, local, utility), + ); let focus = _ => (); }; diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index 1b2750f8bb..8e8cd6bd66 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -152,6 +152,12 @@ color: var(--pat-base); } +.projector.probe .live-offside .closure-groups { + display: flex; + flex-direction: row; + gap: 2px; +} + .projector.probe .closure-group { display: flex; gap: 2px; diff --git a/src/util/ListUtil.re b/src/util/ListUtil.re index b02311e8fe..1496d81f51 100644 --- a/src/util/ListUtil.re +++ b/src/util/ListUtil.re @@ -631,6 +631,10 @@ let rec remove_first_n = (n: int, xs: list('a)): list('a) => { }; }; +/* Return at most k elements starting from index i */ +let slice = (i: int, k: int, xs: list('x)): list('x) => + xs |> remove_first_n(i) |> truncate(k); + let rec rotate_n = (n: int, xs: list('a)): list('a) => { let n = IntUtil.modulo(n, List.length(xs)); switch (n) { From 4c4876514797ddd32266b28f1a7cec4400bf75fe Mon Sep 17 00:00:00 2001 From: disconcision Date: Thu, 16 Jan 2025 22:43:16 -0500 Subject: [PATCH 276/281] projector api addition: overlay view (view which is rendered above the base layer, which contains code text and base projector views). used in probe projector for closure count and pin icons --- src/haz3lcore/zipper/ProjectorBase.re | 25 ++++ .../zipper/projectors/CheckboxProj.re | 1 + src/haz3lcore/zipper/projectors/FoldProj.re | 1 + src/haz3lcore/zipper/projectors/InfoProj.re | 1 + src/haz3lcore/zipper/projectors/ProbeProj.re | 45 ++++--- .../zipper/projectors/SliderFProj.re | 1 + src/haz3lcore/zipper/projectors/SliderProj.re | 1 + .../zipper/projectors/TextAreaProj.re | 1 + src/haz3lweb/app/common/ProjectorView.re | 112 ++++++++++++------ src/haz3lweb/app/editors/code/CodeEditable.re | 5 +- src/haz3lweb/www/style/projectors/base.css | 5 + src/haz3lweb/www/style/projectors/probe.css | 94 +++++++++++---- 12 files changed, 213 insertions(+), 79 deletions(-) diff --git a/src/haz3lcore/zipper/ProjectorBase.re b/src/haz3lcore/zipper/ProjectorBase.re index 29f67c6fc9..66faa3cbfa 100644 --- a/src/haz3lcore/zipper/ProjectorBase.re +++ b/src/haz3lcore/zipper/ProjectorBase.re @@ -132,6 +132,19 @@ module type Projector = { ) => Node.t, ); + /* An optional additional view to be rendered above + * the code / regular projector layer */ + let overlay_view: + option( + ( + model, + info, + ~local: action => Ui_effect.t(unit), + ~parent: external_action => Ui_effect.t(unit), + ~utility: utility + ) => + Node.t, + ); /* How much space should be left in the code view for * this projector? This determines how the base code * view is laid out, including how movement around the @@ -190,6 +203,18 @@ module Cook = (C: Projector) : Cooked => { ), C.offside_view, ); + let overlay_view = + Option.map( + (f, m, info, ~local, ~parent, ~utility) => + f( + deserialize_m(m), + info, + ~local=a => local(serialize_a(a)), + ~parent, + ~utility, + ), + C.overlay_view, + ); let placeholder = m => m |> Sexplib.Sexp.of_string |> C.model_of_sexp |> C.placeholder; let update = (m, i, a) => diff --git a/src/haz3lcore/zipper/projectors/CheckboxProj.re b/src/haz3lcore/zipper/projectors/CheckboxProj.re index 4517ac165c..b724ea20fb 100644 --- a/src/haz3lcore/zipper/projectors/CheckboxProj.re +++ b/src/haz3lcore/zipper/projectors/CheckboxProj.re @@ -57,5 +57,6 @@ module M: Projector = { let update = (model, _, _) => model; let view = view; let offside_view = Option.None; + let overlay_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/FoldProj.re b/src/haz3lcore/zipper/projectors/FoldProj.re index ece0eaec80..ed85fd8628 100644 --- a/src/haz3lcore/zipper/projectors/FoldProj.re +++ b/src/haz3lcore/zipper/projectors/FoldProj.re @@ -27,5 +27,6 @@ module M: Projector = { [text(m.text)], ); let offside_view = Option.None; + let overlay_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/InfoProj.re b/src/haz3lcore/zipper/projectors/InfoProj.re index 0882dea3bf..f193351e33 100644 --- a/src/haz3lcore/zipper/projectors/InfoProj.re +++ b/src/haz3lcore/zipper/projectors/InfoProj.re @@ -94,5 +94,6 @@ module M: Projector = { ], ); let offside_view = Option.None; + let overlay_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index 83a8610102..b1074c7d32 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -185,11 +185,11 @@ module Closures = { let collate = (info: info, model: model, di: list(closure)) - : list(list((int, closure))) => { + : (int, list(list((int, closure)))) => { let closures = select_frames(info, model, di); let numbered_closures = List.mapi((i, c) => (List.length(closures) - i - 1, c), closures); - group(numbered_closures); + (List.length(closures), group(numbered_closures)); }; }; @@ -411,12 +411,10 @@ let nav_bar_view = (model: model, di: list(closure), local) => { ); let show_left = model.index_offset >= List.length(di) - model.max_closures; let show_right = model.index_offset <= 0; - let view = - div( - ~attrs=[Attr.classes(["nav-bar"])], - [nav_arrow(show_left, 1), nav_arrow(show_right, -1)], - ); - List.length(di) > model.max_closures ? [view] : []; + div( + ~attrs=[Attr.classes(["nav-bar"])], + [nav_arrow(show_left, 1), nav_arrow(show_right, -1)], + ); }; let offside_view = (model: model, info: info, local, utility: utility) => @@ -424,12 +422,11 @@ let offside_view = (model: model, info: info, local, utility: utility) => ~attrs=[Attr.classes(["live-offside"])], switch (info.dynamics) { | Some(di) => - let groups = Closures.collate(info, model, di); - let ellipsis = - List.length(di) > model.max_closures ? [ellipsis_view(local)] : []; - nav_bar_view(model, di, local) - @ closure_group_view(info, utility, model, local, groups) - @ ellipsis; + let (num_shown, groups) = Closures.collate(info, model, di); + let is_cut_off = num_shown != Closures.num(info) && num_shown > 0; + let extras = [nav_bar_view(model, di, local), ellipsis_view(local)]; + closure_group_view(info, utility, model, local, groups) + @ (is_cut_off ? extras : []); | _ => [] }, ); @@ -498,7 +495,20 @@ let view = (info: info): Node.t => { Attr.on_double_click(on_double_click), Attr.on_pointerdown(on_pointerdown), ], - [syntax_view(info), icon, num_closures_view(info)] @ pin_view(info), + [syntax_view(info), icon], + ); +}; + +let overlay_view = (info: info): Node.t => { + div( + ~attrs=[ + Attr.classes( + ["overlay"] + @ (Option.is_some(cur_ap_id(info)) ? ["ap"] : []) + @ (State.s.pinned_ap == cur_ap_id(info) ? ["pinned"] : []), + ), + ], + [num_closures_view(info)] @ pin_view(info), ); }; @@ -552,5 +562,10 @@ module M: Projector = { (model, info, ~local, ~parent as _, ~utility) => offside_view(model, info, local, utility), ); + let overlay_view = + Some( + (_model, info, ~local as _, ~parent as _, ~utility as _) => + overlay_view(info), + ); let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/SliderFProj.re b/src/haz3lcore/zipper/projectors/SliderFProj.re index 83f989ceb6..bbf5ff59ae 100644 --- a/src/haz3lcore/zipper/projectors/SliderFProj.re +++ b/src/haz3lcore/zipper/projectors/SliderFProj.re @@ -40,5 +40,6 @@ module M: Projector = { get(info.syntax) |> Printf.sprintf("%.2f"), ); let offside_view = Option.None; + let overlay_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/SliderProj.re b/src/haz3lcore/zipper/projectors/SliderProj.re index 54b1d264ba..ee59602987 100644 --- a/src/haz3lcore/zipper/projectors/SliderProj.re +++ b/src/haz3lcore/zipper/projectors/SliderProj.re @@ -37,5 +37,6 @@ module M: Projector = { get(info.syntax), ); let offside_view = Option.None; + let overlay_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/TextAreaProj.re b/src/haz3lcore/zipper/projectors/TextAreaProj.re index 8ebeb83839..34d618132e 100644 --- a/src/haz3lcore/zipper/projectors/TextAreaProj.re +++ b/src/haz3lcore/zipper/projectors/TextAreaProj.re @@ -110,6 +110,7 @@ module M: Projector = { let update = (model, _, _) => model; let view = view; let offside_view = Option.None; + let overlay_view = Option.None; let focus = ((id: Id.t, d: option(Direction.t))) => { JsUtil.get_elem_by_id(of_id(id))##focus; switch (d) { diff --git a/src/haz3lweb/app/common/ProjectorView.re b/src/haz3lweb/app/common/ProjectorView.re index 42c0028182..66b47b68b7 100644 --- a/src/haz3lweb/app/common/ProjectorView.re +++ b/src/haz3lweb/app/common/ProjectorView.re @@ -71,8 +71,7 @@ let view_wrapper = ~indication: option(Direction.t), ~selected: bool, p: Base.projector, - offside_view: option(Node.t), - view: Node.t, + views: list(Node.t), ) => { let sort = Option.map(Info.sort_of, info.statics) |> Option.value(~default=Sort.Exp); @@ -86,8 +85,7 @@ let view_wrapper = Attr.on_mousedown(focus(info.id)), DecUtil.abs_style(measurement, ~font_metrics), ], - [view, backing_deco(~font_metrics, ~measurement)] - @ Option.to_list(offside_view), + views, ); }; @@ -124,7 +122,7 @@ let offside_pos = offside_offset => /* Gather utility functions/values to be passed to the projector. * See ProjectorBase.utility definition for more information */ -let collate_utility = (globals: Globals.t): ProjectorBase.utility => { +let mk_utility = (globals: Globals.t): ProjectorBase.utility => { { font_metrics: globals.font_metrics, view_seg: (sort, seg) => @@ -151,6 +149,20 @@ let collate_utility = (globals: Globals.t): ProjectorBase.utility => { }; }; +let mk_info = + ( + id: Id.t, + p: Piece.projector, + ~cached_statics: CachedStatics.t, + ~dynamics: Dynamics.Map.t, + ) + : ProjectorBase.info => { + id, + syntax: p.syntax, + statics: Statics.Map.lookup(id, cached_statics.info_map), + dynamics: Dynamics.Map.lookup(id, dynamics), +}; + /* Extracts projector-instance-specific metadata necessary to * render the view, instantiates appropriate action handlers, * renders the view, and then wraps it so as to position it @@ -165,15 +177,12 @@ let setup_view = ~globals: Globals.t, ~indication: option(Direction.t), ) - : option(Node.t) => { + : option((Node.t, option(Node.t))) => { let* p = Id.Map.find_opt(id, cached_syntax.projectors); - let* syntax = Some(p.syntax); - let statics = Statics.Map.lookup(id, cached_statics.info_map); - let dynamics = Dynamics.Map.lookup(id, dynamics); - let info = {id, statics, dynamics, syntax}; let+ measurement = Measured.find_pr_opt(p, cached_syntax.measured); - let utility = collate_utility(globals); let (module P) = to_module(p.kind); + let info = mk_info(id, p, ~cached_statics, ~dynamics); + let utility = mk_utility(globals); let parent = a => inject(Project(handle(id, a))); let local = a => inject(Project(SetModel(id, P.update(p.model, info, a)))); @@ -186,6 +195,7 @@ let setup_view = cached_syntax.measured, ), ); + let base_view = P.view(p.model, info, ~local, ~parent, ~utility); let offside_view = Option.map( v => @@ -195,17 +205,36 @@ let setup_view = ), P.offside_view, ); - view_wrapper( - ~inject, - ~font_metrics=globals.font_metrics, - ~measurement, - ~indication, - ~info, - ~selected=List.mem(id, cached_syntax.selection_ids), - p, - offside_view, - P.view(p.model, info, ~local, ~parent, ~utility), - ); + let overlay_view = + Option.map( + v => + view_wrapper( + ~inject, + ~font_metrics=globals.font_metrics, + ~measurement, + ~indication, + ~info, + ~selected=List.mem(id, cached_syntax.selection_ids), + p, + [v(p.model, info, ~local, ~parent, ~utility)], + ), + P.overlay_view, + ); + let underlay_view = + backing_deco(~font_metrics=globals.font_metrics, ~measurement); + let views = [base_view, underlay_view] @ Option.to_list(offside_view); + let combined_view = + view_wrapper( + ~inject, + ~font_metrics=globals.font_metrics, + ~measurement, + ~indication, + ~info, + ~selected=List.mem(id, cached_syntax.selection_ids), + p, + views, + ); + (combined_view, overlay_view); }; /* Is the piece with id indicated? If so, where is it wrt the caret? */ @@ -226,23 +255,28 @@ let all = ~dynamics: Dynamics.Map.t, ~inject, ) => { - div_c( - "projectors", - Id.Map.bindings(cached_syntax.projectors) - |> List.filter_map(((id, _)) => { - let indication = indication(z, id); - setup_view( - id, - ~cached_statics, - ~cached_syntax, - ~dynamics, - ~inject, - ~globals, - ~indication, - ); - }) - |> List.rev, - ); + let mk_base_view = ((id: Id.t, _)) => { + let indication = indication(z, id); + setup_view( + id, + ~cached_statics, + ~cached_syntax, + ~dynamics, + ~inject, + ~globals, + ~indication, + ); + }; + let projector_ids = cached_syntax.projectors |> Id.Map.bindings |> List.rev; + let (base_views, overlay_views) = + projector_ids |> List.filter_map(mk_base_view) |> List.split; + let overlay_views = overlay_views |> List.filter_map(Fun.id); + [ + div_c( + "projectors", + [div_c("base", base_views), div_c("overlays", overlay_views)], + ), + ]; }; /* When the caret is directly adjacent to a projector, keyboard commands diff --git a/src/haz3lweb/app/editors/code/CodeEditable.re b/src/haz3lweb/app/editors/code/CodeEditable.re index 800a869689..1768a38f5d 100644 --- a/src/haz3lweb/app/editors/code/CodeEditable.re +++ b/src/haz3lweb/app/editors/code/CodeEditable.re @@ -253,7 +253,10 @@ module View = { ~inject=x => inject(Perform(x)), ~dynamics, ); - let overlays = edit_decos @ overlays @ [projectors]; + let overlays = + [Node.div(~attrs=[Attr.classes(["code-deco"])], edit_decos)] + @ [Node.div(~attrs=[Attr.classes(["overlays"])], overlays)] + @ projectors; let code_view = CodeWithStatics.View.view( ~globals, diff --git a/src/haz3lweb/www/style/projectors/base.css b/src/haz3lweb/www/style/projectors/base.css index a807a24a2d..dfca2fa665 100644 --- a/src/haz3lweb/www/style/projectors/base.css +++ b/src/haz3lweb/www/style/projectors/base.css @@ -26,6 +26,11 @@ z-index: var(--projector-z); } +.projectors .overlays .projector { + pointer-events: none; + z-index: var(--code-emblems-z); +} + .projector > svg { z-index: var(--projector-backing-z); fill: var(--shard_projector); diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index 8e8cd6bd66..68b6bd042b 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -18,6 +18,7 @@ --exp-shadow: oklch(0.55 0.15 150); --pat-shadow: oklch(0.5 0.1 245); + --typ-shadow: oklch(0.5 0.1 300); --exp-cell: hsl(115, 30%, 70%); --pat-cell: hsl(165, 30%, 70%); @@ -37,6 +38,10 @@ fill: var(--pat-base); filter: drop-shadow(0.7px 0.7px 0px var(--pat-shadow)); } +.projector.probe:has(.ap.pinned) > svg { + fill: var(--exp-ap-indicated); + filter: drop-shadow(0.7px 0.7px 0px var(--typ-shadow)); +} .projector.probe .main { display: flex; @@ -69,7 +74,9 @@ filter: invert(1); } -.projector.probe .num-closures { +/* OVERLAY VIEW */ + +.overlays .projector.probe .num-closures { position: absolute; right: -0.5em; top: -0.3em; @@ -83,27 +90,24 @@ font-size: 0.7em; padding: 0.3em; min-width: 1em; - z-index: var(--code-emblems-z); } -.projector.probe.Exp .num-closures { +.overlays .projector.probe.Exp .num-closures { background-color: var(--exp-indicated); } -.projector.probe.Pat .num-closures { +.overlays .projector.probe.Pat .num-closures { background-color: var(--pat-indicated); } -.projector.probe.selected .num-closures { +.overlays .projector.probe.selected .num-closures { background-color: var(--num-closures); } -.projector.probe.indicated.Right .num-closures { +.overlays .projector.probe.indicated.Right .num-closures { background-color: var(--num-closures-indicated) !important; - right: -0.8em; - top: -0.5em; } -.projector.probe:has(.main.ap.pinned) .num-closures { +.overlays .projector.probe:has(.ap.pinned) .num-closures { background-color: var(--exp-ap-indicated); } -.projector.probe .pin { +.overlays .projector.probe .pin { position: absolute; left: -0.5em; top: -0.3em; @@ -117,17 +121,17 @@ background-position: center; background-repeat: no-repeat; } -.projector.probe.indicated.Left .pin { +.overlays .projector.probe.indicated.Left .pin { background-color: oklch(0.8 0.18 201.83); - left: -0.61em; - top: -0.5em; } +/* OFFSIDE VIEW */ + .projector.probe .live-offside { display: flex; flex-direction: row; align-items: center; - gap: 2px; + gap: 6px; } .projector.probe .live-offside:empty { display: none; @@ -139,17 +143,21 @@ align-items: center; gap: 2px; position: absolute; - left: -1.35em; + left: -1.75em; } .projector.probe .live-offside .ellipsis { cursor: pointer; } .projector.probe.Exp .live-offside .ellipsis { - color: var(--exp-base); + color: var(--exp-indicated); } .projector.probe.Pat .live-offside .ellipsis { - color: var(--pat-base); + color: var(--pat-indicated); +} +.projector.probe .live-offside .ellipsis:hover { + /* filter: brightness(1.2) saturate(2); */ + scale: 1.4; } .projector.probe .live-offside .closure-groups { @@ -167,9 +175,14 @@ .projector.probe .closure-group:not(:last-child)::after { content: "•"; font-size: 0.4em; - color: var(--exp-indicated); margin: -1px; } +.projector.probe.Exp .closure-group:not(:last-child)::after { + color: var(--exp-indicated); +} +.projector.probe.Pat .closure-group:not(:last-child)::after { + color: var(--pat-indicated); +} .projector.probe .val-resize { cursor: pointer; @@ -197,10 +210,12 @@ .projector.probe .val-resize.cursor-ap-lex .code-text { opacity: 100%; outline: 1px solid var(--exp-ap-indicated); + border-color: var(--exp-ap-indicated); } .projector.probe .val-resize.cursor-outer-ap .code-text { opacity: 100% !important; outline: 1px solid var(--exp-ap-indicated); + border-color: var(--exp-ap-indicated); background-color: var(--exp-ap-indicated); } .projector.probe .val-resize .code-text, @@ -215,7 +230,7 @@ } .projector.probe.indicated .closure.cursor .val-resize .code-text { opacity: 100%; - background: none; + background: white; outline-width: 2.8px; outline-style: solid; } @@ -227,6 +242,7 @@ } .projector.probe.indicated .val-resize.cursor-lex.ap .code-text { outline-color: var(--exp-ap-indicated); + border-color: var(--exp-ap-indicated); } /* TOKENS */ @@ -240,7 +256,29 @@ } .projector.probe .val-resize .code-text:hover { - filter: brightness(1.05) saturate(1.05); + opacity: 100% !important; + outline-width: 1px; + outline-style: solid; + outline-offset: -0.1px; + border-width: 1.5px; + top: 0.5px; +} +.projector.probe.Exp .val-resize .code-text:hover { + outline-color: var(--exp-indicated); + border-color: var(--exp-indicated); +} +.projector.probe.Pat .val-resize .code-text:hover { + outline-color: var(--pat-indicated); + border-color: var(--pat-indicated); +} +.projector.probe.Exp .val-resize.ap .code-text:hover { + outline-color: var(--exp-ap-indicated); + border-color: var(--exp-ap-indicated); +} +.projector.probe .val-resize > .code:hover { + scale: 1.125; + z-index: 5000; + position: relative; } .projector.probe .live-env { @@ -266,7 +304,7 @@ .projector.probe.indicated.Pat > svg { fill: var(--pat-indicated); } -.projector.probe:has(.main.ap.pinned) > svg { +.projector.probe:has(.ap.pinned) > svg { fill: var(--exp-ap-indicated); } @@ -287,16 +325,24 @@ .projector.probe .nav-arrow { width: 10px; height: 13px; - cursor: pointer; + color: var(--exp-indicated); background: url(../../img/noun-arrow-3130579.svg); background-size: cover; color: var(--NONE); - filter: invert(1) brightness(0.5) sepia(1) hue-rotate(61deg); +} +.projector.probe .nav-arrow:not(.disabled) { + cursor: pointer; } .projector.probe .nav-arrow:last-child { transform: rotate(180deg); } +.projector.probe.Exp .nav-arrow { + filter: invert(1) brightness(0.7) sepia(1) hue-rotate(61deg) saturate(0.6); +} +.projector.probe.Pat .nav-arrow { + filter: invert(1) brightness(0.7) sepia(1) hue-rotate(141deg) saturate(0.6); +} .projector.probe:not(.indicated) .nav-arrow { pointer-events: none; @@ -307,6 +353,6 @@ opacity: 15%; } -.projector.probe .nav-arrow:hover { +.projector.probe .nav-arrow:not(.disabled):hover { filter: brightness(1.05) saturate(1.05); } From de876b5e42c208ff1967b4bb55692876a6d2bd84 Mon Sep 17 00:00:00 2001 From: disconcision Date: Fri, 17 Jan 2025 00:25:26 -0500 Subject: [PATCH 277/281] added optional underlay view to projectors API --- src/haz3lcore/zipper/ProjectorBase.re | 16 ++++- .../zipper/projectors/CheckboxProj.re | 1 + src/haz3lcore/zipper/projectors/FoldProj.re | 1 + src/haz3lcore/zipper/projectors/InfoProj.re | 1 + src/haz3lcore/zipper/projectors/ProbeProj.re | 1 + .../zipper/projectors/SliderFProj.re | 1 + src/haz3lcore/zipper/projectors/SliderProj.re | 1 + .../zipper/projectors/TextAreaProj.re | 1 + src/haz3lweb/app/common/ProjectorView.re | 68 ++++++++----------- src/haz3lweb/www/style/dynamics.css | 8 +-- src/haz3lweb/www/style/exercise-mode.css | 2 +- src/haz3lweb/www/style/projectors/base.css | 12 ++-- src/haz3lweb/www/style/projectors/probe.css | 40 ++++++++--- src/haz3lweb/www/style/variables.css | 15 ++-- src/util/ListUtil.re | 17 +++++ 15 files changed, 119 insertions(+), 66 deletions(-) diff --git a/src/haz3lcore/zipper/ProjectorBase.re b/src/haz3lcore/zipper/ProjectorBase.re index 66faa3cbfa..d15dbb40d6 100644 --- a/src/haz3lcore/zipper/ProjectorBase.re +++ b/src/haz3lcore/zipper/ProjectorBase.re @@ -132,7 +132,7 @@ module type Projector = { ) => Node.t, ); - /* An optional additional view to be rendered above + /* An optional view to be rendered above * the code / regular projector layer */ let overlay_view: option( @@ -145,6 +145,15 @@ module type Projector = { ) => Node.t, ); + /* An optional view to be rendered below the code and + * regular projector layer. If this is provided, + * regular underlays like indication and selection + * decorations will not be drawn; projector clients + * should use the classes placed on the wrapping + * element to trigger their own custom indication and + * selection decorations. Pointer handlers should not + * be placed on this layer. */ + let underlay_view: option((model, info, ~utility: utility) => Node.t); /* How much space should be left in the code view for * this projector? This determines how the base code * view is laid out, including how movement around the @@ -215,6 +224,11 @@ module Cook = (C: Projector) : Cooked => { ), C.overlay_view, ); + let underlay_view = + Option.map( + (f, m, info, ~utility) => f(deserialize_m(m), info, ~utility), + C.underlay_view, + ); let placeholder = m => m |> Sexplib.Sexp.of_string |> C.model_of_sexp |> C.placeholder; let update = (m, i, a) => diff --git a/src/haz3lcore/zipper/projectors/CheckboxProj.re b/src/haz3lcore/zipper/projectors/CheckboxProj.re index b724ea20fb..68745febbd 100644 --- a/src/haz3lcore/zipper/projectors/CheckboxProj.re +++ b/src/haz3lcore/zipper/projectors/CheckboxProj.re @@ -58,5 +58,6 @@ module M: Projector = { let view = view; let offside_view = Option.None; let overlay_view = Option.None; + let underlay_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/FoldProj.re b/src/haz3lcore/zipper/projectors/FoldProj.re index ed85fd8628..9593719707 100644 --- a/src/haz3lcore/zipper/projectors/FoldProj.re +++ b/src/haz3lcore/zipper/projectors/FoldProj.re @@ -28,5 +28,6 @@ module M: Projector = { ); let offside_view = Option.None; let overlay_view = Option.None; + let underlay_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/InfoProj.re b/src/haz3lcore/zipper/projectors/InfoProj.re index f193351e33..de69e7c5bd 100644 --- a/src/haz3lcore/zipper/projectors/InfoProj.re +++ b/src/haz3lcore/zipper/projectors/InfoProj.re @@ -95,5 +95,6 @@ module M: Projector = { ); let offside_view = Option.None; let overlay_view = Option.None; + let underlay_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index b1074c7d32..6884f4da5b 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -567,5 +567,6 @@ module M: Projector = { (_model, info, ~local as _, ~parent as _, ~utility as _) => overlay_view(info), ); + let underlay_view = Option.None; //TODO let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/SliderFProj.re b/src/haz3lcore/zipper/projectors/SliderFProj.re index bbf5ff59ae..af58373a3a 100644 --- a/src/haz3lcore/zipper/projectors/SliderFProj.re +++ b/src/haz3lcore/zipper/projectors/SliderFProj.re @@ -41,5 +41,6 @@ module M: Projector = { ); let offside_view = Option.None; let overlay_view = Option.None; + let underlay_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/SliderProj.re b/src/haz3lcore/zipper/projectors/SliderProj.re index ee59602987..bfe0cb5df4 100644 --- a/src/haz3lcore/zipper/projectors/SliderProj.re +++ b/src/haz3lcore/zipper/projectors/SliderProj.re @@ -38,5 +38,6 @@ module M: Projector = { ); let offside_view = Option.None; let overlay_view = Option.None; + let underlay_view = Option.None; let focus = _ => (); }; diff --git a/src/haz3lcore/zipper/projectors/TextAreaProj.re b/src/haz3lcore/zipper/projectors/TextAreaProj.re index 34d618132e..cf519edb20 100644 --- a/src/haz3lcore/zipper/projectors/TextAreaProj.re +++ b/src/haz3lcore/zipper/projectors/TextAreaProj.re @@ -111,6 +111,7 @@ module M: Projector = { let view = view; let offside_view = Option.None; let overlay_view = Option.None; + let underlay_view = Option.None; //TODO let focus = ((id: Id.t, d: option(Direction.t))) => { JsUtil.get_elem_by_id(of_id(id))##focus; switch (d) { diff --git a/src/haz3lweb/app/common/ProjectorView.re b/src/haz3lweb/app/common/ProjectorView.re index 66b47b68b7..560f33a2a7 100644 --- a/src/haz3lweb/app/common/ProjectorView.re +++ b/src/haz3lweb/app/common/ProjectorView.re @@ -174,10 +174,10 @@ let setup_view = ~cached_syntax: Editor.CachedSyntax.t, ~dynamics, ~inject: Action.t => Ui_effect.t(unit), - ~globals: Globals.t, + ~globals as {font_metrics, _} as globals: Globals.t, ~indication: option(Direction.t), ) - : option((Node.t, option(Node.t))) => { + : option((Node.t, Node.t, option(Node.t))) => { let* p = Id.Map.find_opt(id, cached_syntax.projectors); let+ measurement = Measured.find_pr_opt(p, cached_syntax.measured); let (module P) = to_module(p.kind); @@ -188,14 +188,19 @@ let setup_view = inject(Project(SetModel(id, P.update(p.model, info, a)))); let offside_pos = offside_pos( - offside( - ~offset=4, - globals.font_metrics, - measurement, - cached_syntax.measured, - ), + offside(~offset=4, font_metrics, measurement, cached_syntax.measured), + ); + let wrapper = + view_wrapper( + ~inject, + ~font_metrics, + ~measurement, + ~indication, + ~info, + ~selected=List.mem(id, cached_syntax.selection_ids), + p, ); - let base_view = P.view(p.model, info, ~local, ~parent, ~utility); + let inline_view = P.view(p.model, info, ~local, ~parent, ~utility); let offside_view = Option.map( v => @@ -207,34 +212,16 @@ let setup_view = ); let overlay_view = Option.map( - v => - view_wrapper( - ~inject, - ~font_metrics=globals.font_metrics, - ~measurement, - ~indication, - ~info, - ~selected=List.mem(id, cached_syntax.selection_ids), - p, - [v(p.model, info, ~local, ~parent, ~utility)], - ), + v => wrapper([v(p.model, info, ~local, ~parent, ~utility)]), P.overlay_view, ); let underlay_view = - backing_deco(~font_metrics=globals.font_metrics, ~measurement); - let views = [base_view, underlay_view] @ Option.to_list(offside_view); - let combined_view = - view_wrapper( - ~inject, - ~font_metrics=globals.font_metrics, - ~measurement, - ~indication, - ~info, - ~selected=List.mem(id, cached_syntax.selection_ids), - p, - views, - ); - (combined_view, overlay_view); + switch (P.underlay_view) { + | Some(v) => wrapper([v(p.model, info, ~utility)]) + | None => wrapper([backing_deco(~font_metrics, ~measurement)]) + }; + let combined_view = wrapper([inline_view] @ Option.to_list(offside_view)); + (underlay_view, combined_view, overlay_view); }; /* Is the piece with id indicated? If so, where is it wrt the caret? */ @@ -255,7 +242,7 @@ let all = ~dynamics: Dynamics.Map.t, ~inject, ) => { - let mk_base_view = ((id: Id.t, _)) => { + let mk_views = ((id: Id.t, _)) => { let indication = indication(z, id); setup_view( id, @@ -268,13 +255,18 @@ let all = ); }; let projector_ids = cached_syntax.projectors |> Id.Map.bindings |> List.rev; - let (base_views, overlay_views) = - projector_ids |> List.filter_map(mk_base_view) |> List.split; + + let (underlay_views, base_views, overlay_views) = + projector_ids |> List.filter_map(mk_views) |> ListUtil.split3; let overlay_views = overlay_views |> List.filter_map(Fun.id); [ div_c( "projectors", - [div_c("base", base_views), div_c("overlays", overlay_views)], + [ + div_c("base", base_views), + div_c("underlays", underlay_views), + div_c("overlays", overlay_views), + ], ), ]; }; diff --git a/src/haz3lweb/www/style/dynamics.css b/src/haz3lweb/www/style/dynamics.css index 822f216481..cdc7759eb2 100644 --- a/src/haz3lweb/www/style/dynamics.css +++ b/src/haz3lweb/www/style/dynamics.css @@ -309,17 +309,17 @@ } .tile-next-step .tile-path.Exp.indicated { - fill: var(--G1) + fill: var(--G1); } .tile-taken-step .tile-path.Exp.indicated { - fill: var(--BR1) + fill: var(--BR1); } svg.tile-next-step { pointer-events: all; cursor: pointer; - z-index: var(--test-result-z); + z-index: var(--projector-overlay-z); filter: drop-shadow(1px 1px var(--G2)); } @@ -337,4 +337,4 @@ svg.tile-taken-step { .cell-result .code { pointer-events: none; -} \ No newline at end of file +} diff --git a/src/haz3lweb/www/style/exercise-mode.css b/src/haz3lweb/www/style/exercise-mode.css index 1dac832e86..98d965b23d 100644 --- a/src/haz3lweb/www/style/exercise-mode.css +++ b/src/haz3lweb/www/style/exercise-mode.css @@ -99,7 +99,7 @@ margin-left: 0.17em; font-size: 64%; vertical-align: super; - z-index: var(--test-result-z); + z-index: var(--projector-overlay-z); } .test-instance.Pass:before, diff --git a/src/haz3lweb/www/style/projectors/base.css b/src/haz3lweb/www/style/projectors/base.css index dfca2fa665..45108b2997 100644 --- a/src/haz3lweb/www/style/projectors/base.css +++ b/src/haz3lweb/www/style/projectors/base.css @@ -4,7 +4,7 @@ @import "probe.css"; /* Turn off caret when a projector is focused */ -#caret:has(~ .projectors .projector *:focus) .caret-path { +.code-deco:has(~ .projectors .projector *:focus) #caret .caret-path { fill: #0000; } @@ -19,7 +19,7 @@ } .projector.indicated { - z-index: var(--code-hovers-z); + z-index: var(--projector-indicated-z); } .projector > *:not(svg) { @@ -28,11 +28,15 @@ .projectors .overlays .projector { pointer-events: none; - z-index: var(--code-emblems-z); + z-index: var(--projector-overlay-z); +} + +.projectors .underlays .projector { + pointer-events: none; + z-index: var(--projector-underlay-z); } .projector > svg { - z-index: var(--projector-backing-z); fill: var(--shard_projector); } diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index 68b6bd042b..a68f13f871 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -69,7 +69,7 @@ .projector.probe .main.ap .icon { background-image: url(../../img/noun-telescope-7245201.svg); } -.projector.probe.indicated .main .icon, +.projector.probe.indicated:not(.selected) .main .icon, .projector.probe .main.ap.pinned .icon { filter: invert(1); } @@ -90,21 +90,39 @@ font-size: 0.7em; padding: 0.3em; min-width: 1em; + --original-bg: inherit; + background-color: var(--original-bg); } .overlays .projector.probe.Exp .num-closures { - background-color: var(--exp-indicated); + --original-bg: var(--exp-indicated); } .overlays .projector.probe.Pat .num-closures { - background-color: var(--pat-indicated); + --original-bg: var(--pat-indicated); } .overlays .projector.probe.selected .num-closures { - background-color: var(--num-closures); + --original-bg: var(--num-closures); +} +.overlays .projector.probe:has(.ap.pinned) .num-closures { + --original-bg: var(--exp-ap-indicated); +} +@keyframes blink-probe-caret { + from, + to { + background-color: var(--R1); + } + + 50% { + background-color: var(--original-bg); + } } .overlays .projector.probe.indicated.Right .num-closures { - background-color: var(--num-closures-indicated) !important; + animation: 1s blink-probe-caret step-end infinite; + + /* background-color: var(--num-closures-indicated) !important; */ } -.overlays .projector.probe:has(.ap.pinned) .num-closures { - background-color: var(--exp-ap-indicated); + +.overlays .projector.probe.selected:not(.indicated) .num-closures { + color: var(--STONE); } .overlays .projector.probe .pin { @@ -114,7 +132,6 @@ height: 0.8em; width: 0.8em; border-radius: 2em; - z-index: var(--code-emblems-z); filter: invert(1); background: url(../../img/noun-pinned-1560993.svg) oklch(0.65 0.18 137.67); background-size: 70%; @@ -277,7 +294,7 @@ } .projector.probe .val-resize > .code:hover { scale: 1.125; - z-index: 5000; + z-index: var(--projector-indicated-z); position: relative; } @@ -298,6 +315,9 @@ color: var(--GB0); } +.projector.probe.selected > svg { + display: none; +} .projector.probe.indicated > svg { fill: var(--exp-indicated); } @@ -311,7 +331,7 @@ .projector.probe .main.ap.pinned { color: white; } -.projector.probe.indicated .main { +.projector.probe.indicated:not(.selected) .main { color: white; } diff --git a/src/haz3lweb/www/style/variables.css b/src/haz3lweb/www/style/variables.css index 8859a25eab..b5d342ed67 100644 --- a/src/haz3lweb/www/style/variables.css +++ b/src/haz3lweb/www/style/variables.css @@ -197,10 +197,9 @@ /* BELOW CODE LEVEL */ --err-hole-arms-z: 0; --tile-z: 1; - --projector-backing-z: 1; --err-hole-z: 2; --select-z: 4; - --test-result-z: 5; + --projector-underlay-z: 9; /* AT CODE LEVEL */ --code-text-z: 10; @@ -209,16 +208,16 @@ /* ABOVE CODE LEVEL */ --backpack-targets-z: 11; - --code-hovers-z: 11; + --projector-indicated-z: 11; --stepper-interactive-z: 15; --caret-z: 20; - --code-emblems-z: 21; + --projector-overlay-z: 29; /* TOP LEVEL UI */ - --context-inspector-z: 29; /* keep below bottom bar */ - --bottom-bar-z: 30; - --top-bar-z: 30; - --explainthis-expander-z: 30; + --context-inspector-z: 30; /* keep below bottom bar */ + --bottom-bar-z: 31; + --top-bar-z: 31; + --explainthis-expander-z: 31; /* HACKS */ --overlay-z: 100; diff --git a/src/util/ListUtil.re b/src/util/ListUtil.re index 1496d81f51..a3ec1d1e4b 100644 --- a/src/util/ListUtil.re +++ b/src/util/ListUtil.re @@ -652,3 +652,20 @@ let take = (n, xs) => { }; loop(n, xs, []); }; + +let split3 = (xs: list(('a, 'b, 'c))): (list('a), list('b), list('c)) => { + let rec aux = + ( + xs: list(('a, 'b, 'c)), + acc1: list('a), + acc2: list('b), + acc3: list('c), + ) => { + switch (xs) { + | [] => (List.rev(acc1), List.rev(acc2), List.rev(acc3)) + | [(x, y, z), ...rest] => + aux(rest, [x, ...acc1], [y, ...acc2], [z, ...acc3]) + }; + }; + aux(xs, [], [], []); +}; From 620fcff60844a57b99753f7ed8a3cb80f8e56163 Mon Sep 17 00:00:00 2001 From: disconcision Date: Fri, 17 Jan 2025 01:01:34 -0500 Subject: [PATCH 278/281] equals sign for projectors. fix pin deco somewhat. better value abbreviation on the lower limit --- src/haz3lcore/pretty/Abbreviate.re | 5 +-- src/haz3lcore/zipper/projectors/ProbeProj.re | 6 +++- src/haz3lweb/www/style/projectors/probe.css | 34 ++++++++++++-------- 3 files changed, 28 insertions(+), 17 deletions(-) diff --git a/src/haz3lcore/pretty/Abbreviate.re b/src/haz3lcore/pretty/Abbreviate.re index 0cc242db76..fffb9acb19 100644 --- a/src/haz3lcore/pretty/Abbreviate.re +++ b/src/haz3lcore/pretty/Abbreviate.re @@ -164,10 +164,11 @@ let rec abbreviate_exp = (exp: Exp.t): Exp.t => { let abbreviate_exp = (~available as a=12, exp: Exp.t): (Exp.t, bool) => { available := a; - available^ <= 1 + let exp = abbreviate_exp(exp); + let length_exp = a - available^; + a < 0 || a <= 1 && length_exp > 1 ? (ellipses_term(), false) : { - let exp = abbreviate_exp(exp); (exp, available^ < 0); }; }; diff --git a/src/haz3lcore/zipper/projectors/ProbeProj.re b/src/haz3lcore/zipper/projectors/ProbeProj.re index 6884f4da5b..3cd060da15 100644 --- a/src/haz3lcore/zipper/projectors/ProbeProj.re +++ b/src/haz3lcore/zipper/projectors/ProbeProj.re @@ -417,6 +417,9 @@ let nav_bar_view = (model: model, di: list(closure), local) => { ); }; +let equals_view = + div(~attrs=[Attr.classes(["live-equals"])], [text("=")]); + let offside_view = (model: model, info: info, local, utility: utility) => Node.div( ~attrs=[Attr.classes(["live-offside"])], @@ -425,7 +428,8 @@ let offside_view = (model: model, info: info, local, utility: utility) => let (num_shown, groups) = Closures.collate(info, model, di); let is_cut_off = num_shown != Closures.num(info) && num_shown > 0; let extras = [nav_bar_view(model, di, local), ellipsis_view(local)]; - closure_group_view(info, utility, model, local, groups) + (num_shown > 0 ? [equals_view] : []) + @ closure_group_view(info, utility, model, local, groups) @ (is_cut_off ? extras : []); | _ => [] }, diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index a68f13f871..4c66ac3f16 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -38,10 +38,6 @@ fill: var(--pat-base); filter: drop-shadow(0.7px 0.7px 0px var(--pat-shadow)); } -.projector.probe:has(.ap.pinned) > svg { - fill: var(--exp-ap-indicated); - filter: drop-shadow(0.7px 0.7px 0px var(--typ-shadow)); -} .projector.probe .main { display: flex; @@ -69,8 +65,7 @@ .projector.probe .main.ap .icon { background-image: url(../../img/noun-telescope-7245201.svg); } -.projector.probe.indicated:not(.selected) .main .icon, -.projector.probe .main.ap.pinned .icon { +.projector.probe.indicated:not(.selected) .main .icon { filter: invert(1); } @@ -102,9 +97,7 @@ .overlays .projector.probe.selected .num-closures { --original-bg: var(--num-closures); } -.overlays .projector.probe:has(.ap.pinned) .num-closures { - --original-bg: var(--exp-ap-indicated); -} + @keyframes blink-probe-caret { from, to { @@ -133,7 +126,7 @@ width: 0.8em; border-radius: 2em; filter: invert(1); - background: url(../../img/noun-pinned-1560993.svg) oklch(0.65 0.18 137.67); + background: url(../../img/noun-pinned-1560993.svg) #33ffff; background-size: 70%; background-position: center; background-repeat: no-repeat; @@ -154,6 +147,16 @@ display: none; } +.projector.probe .live-equals { + font-weight: 800; + color: var(--exp-base); + opacity: 80%; +} +.projector.probe.indicated .live-equals { + opacity: 100%; + color: var(--exp-indicated); +} + .projector.probe .live-offside .nav-bar { display: flex; flex-direction: row; @@ -167,9 +170,15 @@ cursor: pointer; } .projector.probe.Exp .live-offside .ellipsis { - color: var(--exp-indicated); + color: var(--exp-base); } .projector.probe.Pat .live-offside .ellipsis { + color: var(--pat-base); +} +.projector.probe.indicated.Exp .live-offside .ellipsis { + color: var(--exp-indicated); +} +.projector.probe.indicated.Pat .live-offside .ellipsis { color: var(--pat-indicated); } .projector.probe .live-offside .ellipsis:hover { @@ -328,9 +337,6 @@ fill: var(--exp-ap-indicated); } -.projector.probe .main.ap.pinned { - color: white; -} .projector.probe.indicated:not(.selected) .main { color: white; } From 60e980d7bd31ae5f9a2137028e5982c5c2bc3edd Mon Sep 17 00:00:00 2001 From: disconcision Date: Fri, 17 Jan 2025 01:14:38 -0500 Subject: [PATCH 279/281] probe style tweaks --- src/haz3lweb/www/style/projectors/probe.css | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/haz3lweb/www/style/projectors/probe.css b/src/haz3lweb/www/style/projectors/probe.css index 4c66ac3f16..f5fef59bd8 100644 --- a/src/haz3lweb/www/style/projectors/probe.css +++ b/src/haz3lweb/www/style/projectors/probe.css @@ -288,6 +288,7 @@ outline-offset: -0.1px; border-width: 1.5px; top: 0.5px; + filter: drop-shadow(1.5px 3px 0 #95876452); } .projector.probe.Exp .val-resize .code-text:hover { outline-color: var(--exp-indicated); @@ -302,6 +303,7 @@ border-color: var(--exp-ap-indicated); } .projector.probe .val-resize > .code:hover { + transform-origin: center left; scale: 1.125; z-index: var(--projector-indicated-z); position: relative; From 127f6f1c16859ad621ac46d9d2b1369f1d648fa8 Mon Sep 17 00:00:00 2001 From: disconcision Date: Fri, 17 Jan 2025 13:45:13 -0500 Subject: [PATCH 280/281] refactor projector view data flow --- src/haz3lweb/app/common/ProjectorView.re | 168 ++++++++++-------- src/haz3lweb/app/editors/code/Code.re | 10 +- src/haz3lweb/app/editors/code/CodeEditable.re | 17 +- 3 files changed, 105 insertions(+), 90 deletions(-) diff --git a/src/haz3lweb/app/common/ProjectorView.re b/src/haz3lweb/app/common/ProjectorView.re index 560f33a2a7..86553f3429 100644 --- a/src/haz3lweb/app/common/ProjectorView.re +++ b/src/haz3lweb/app/common/ProjectorView.re @@ -97,53 +97,33 @@ let handle = (id, action: external_action): Action.project => | SetSyntax(f) => SetSyntax(id, f) }; -/* Position in pixels for the position offset characters to the - * right of the end of the row at measurement.origin. */ -let offside = - ( - ~offset: int, - font_metrics: FontMetrics.t, - measurement: Measured.measurement, - measured: Measured.t, - ) - : float => - font_metrics.col_width - *. float_of_int( - Measured.start_row_width(measurement, measured) - + offset - - measurement.origin.col, - ); - -let offside_pos = offside_offset => - Attr.create( - "style", - Printf.sprintf("position: absolute; left: %fpx;", offside_offset), +let offside_wrapper = + (font_metrics: FontMetrics.t, offside_base: int, v: Node.t) => + div( + ~attrs=[ + Attr.create( + "style", + Printf.sprintf( + "position: absolute; left: %fpx;", + font_metrics.col_width *. float_of_int(offside_base), + ), + ), + ], + [v], ); /* Gather utility functions/values to be passed to the projector. * See ProjectorBase.utility definition for more information */ -let mk_utility = (globals: Globals.t): ProjectorBase.utility => { +let mk_utility = (font_metrics: FontMetrics.t): ProjectorBase.utility => { { - font_metrics: globals.font_metrics, - view_seg: (sort, seg) => - CodeViewable.view_segment( - ~globals, - ~sort, - ~shape_of_proj=Projector.Shape.of_map_default, - seg, - ), + font_metrics, + view_seg: Code.simple_view(font_metrics), exp_to_seg: exp => exp |> DHExp.strip_casts |> ExpToSegment.exp_to_segment( - ~settings={ - inline: false, - fold_case_clauses: false, - fold_fn_bodies: false, - hide_fixpoints: false, - fold_cast_types: false, - show_filters: false, - }, + ~settings= + ExpToSegment.Settings.of_core(~inline=false, CoreSettings.off), ), seg_to_exp: seg => MakeTerm.go(seg).term, }; @@ -163,33 +143,74 @@ let mk_info = dynamics: Dynamics.Map.lookup(id, dynamics), }; +let indication = (z, id) => + switch (Indicated.piece(z)) { + | Some((p, d, _)) when Piece.id(p) == id => Some(Direction.toggle(d)) + | _ => None + }; + +let offside_base = + (~offset: int, measurement: Measured.measurement, measured: Measured.t) + : int => + Measured.start_row_width(measurement, measured) + + offset + - measurement.origin.col; + +type projector_data = { + p: Piece.projector, + indication: option(Direction.t), + selected: bool, + info: ProjectorBase.info, + measurement: Measured.measurement, + offside_base: int, +}; + +let get_data = + ( + id, + cached_syntax: Editor.CachedSyntax.t, + cached_statics: CachedStatics.t, + dynamics: Dynamics.Map.t, + zipper: Zipper.t, + ) + : option(projector_data) => { + let* p = Id.Map.find_opt(id, cached_syntax.projectors); + let+ measurement = Measured.find_pr_opt(p, cached_syntax.measured); + { + p, + indication: indication(zipper, id), + selected: List.mem(id, cached_syntax.selection_ids), + measurement, + info: mk_info(id, p, ~cached_statics, ~dynamics), + offside_base: + offside_base(~offset=4, measurement, cached_syntax.measured), + }; +}; + +let collect_data = (syntax: Editor.CachedSyntax.t, zipper, statics, dynamics) => { + let projector_ids = syntax.projectors |> Id.Map.bindings |> List.rev; + List.filter_map( + ((id, _)) => get_data(id, syntax, statics, dynamics, zipper), + projector_ids, + ); +}; + /* Extracts projector-instance-specific metadata necessary to * render the view, instantiates appropriate action handlers, * renders the view, and then wraps it so as to position it * correctly with respect to the underyling editor */ let setup_view = ( - id: Id.t, - ~cached_statics: CachedStatics.t, - ~cached_syntax: Editor.CachedSyntax.t, - ~dynamics, - ~inject: Action.t => Ui_effect.t(unit), - ~globals as {font_metrics, _} as globals: Globals.t, - ~indication: option(Direction.t), + inject: Action.t => Ui_effect.t(unit), + utility: ProjectorBase.utility, + font_metrics: FontMetrics.t, + {p, info, offside_base, indication, measurement, selected}: projector_data, ) - : option((Node.t, Node.t, option(Node.t))) => { - let* p = Id.Map.find_opt(id, cached_syntax.projectors); - let+ measurement = Measured.find_pr_opt(p, cached_syntax.measured); + : (Node.t, Node.t, option(Node.t)) => { let (module P) = to_module(p.kind); - let info = mk_info(id, p, ~cached_statics, ~dynamics); - let utility = mk_utility(globals); - let parent = a => inject(Project(handle(id, a))); + let parent = a => inject(Project(handle(p.id, a))); let local = a => - inject(Project(SetModel(id, P.update(p.model, info, a)))); - let offside_pos = - offside_pos( - offside(~offset=4, font_metrics, measurement, cached_syntax.measured), - ); + inject(Project(SetModel(p.id, P.update(p.model, info, a)))); let wrapper = view_wrapper( ~inject, @@ -197,16 +218,17 @@ let setup_view = ~measurement, ~indication, ~info, - ~selected=List.mem(id, cached_syntax.selection_ids), + ~selected, p, ); let inline_view = P.view(p.model, info, ~local, ~parent, ~utility); let offside_view = Option.map( v => - div( - ~attrs=[offside_pos], - [v(p.model, info, ~local, ~parent, ~utility)], + offside_wrapper( + font_metrics, + offside_base, + v(p.model, info, ~local, ~parent, ~utility), ), P.offside_view, ); @@ -235,29 +257,17 @@ let indication = (z, id) => * be absolutely positioned atop a rendered editor UI */ let all = ( - z, - ~globals: Globals.t, - ~cached_statics: CachedStatics.t, - ~cached_syntax: Editor.CachedSyntax.t, - ~dynamics: Dynamics.Map.t, - ~inject, + inject: Action.t => Ui_effect.t(unit), + utility: ProjectorBase.utility, + font_metrics: FontMetrics.t, + pairs: list(projector_data), ) => { - let mk_views = ((id: Id.t, _)) => { - let indication = indication(z, id); - setup_view( - id, - ~cached_statics, - ~cached_syntax, - ~dynamics, - ~inject, - ~globals, - ~indication, - ); + let mk_views = (bleh: projector_data) => { + setup_view(inject, utility, font_metrics, bleh); }; - let projector_ids = cached_syntax.projectors |> Id.Map.bindings |> List.rev; let (underlay_views, base_views, overlay_views) = - projector_ids |> List.filter_map(mk_views) |> ListUtil.split3; + pairs |> List.map(mk_views) |> ListUtil.split3; let overlay_views = overlay_views |> List.filter_map(Fun.id); [ div_c( diff --git a/src/haz3lweb/app/editors/code/Code.re b/src/haz3lweb/app/editors/code/Code.re index 01763d2426..65677d82a2 100644 --- a/src/haz3lweb/app/editors/code/Code.re +++ b/src/haz3lweb/app/editors/code/Code.re @@ -155,24 +155,24 @@ let rec holes = ], ); -let simple_view = (~font_metrics, ~segment, ~settings: Settings.t): Node.t => { - let shape_of_proj = Projector.Shape.of_map_default; /* Assume this doesn't contain projectors */ +let simple_view = (font_metrics, sort, segment): Node.t => { + let shape_of_proj = Projector.Shape.of_map_default; let map = Measured.of_segment(segment, shape_of_proj); module Text = Text({ let map = map; - let settings = settings; + let settings = Settings.Model.init; let shape_of_proj = shape_of_proj; }); let holes = holes(~map, ~font_metrics, segment); div( ~attrs=[Attr.class_("code")], [ - span_c("code-text", Text.of_segment([], false, Sort.Any, segment)), + span_c("code-text", Text.of_segment([], false, sort, segment)), ...holes, ], ); -}; +}; /* Assume this doesn't contain projectors */ let of_hole = (~globals: Globals.t, ~measured, g: Grout.t) => // TODO(d) fix sort diff --git a/src/haz3lweb/app/editors/code/CodeEditable.re b/src/haz3lweb/app/editors/code/CodeEditable.re index 1768a38f5d..2c74307449 100644 --- a/src/haz3lweb/app/editors/code/CodeEditable.re +++ b/src/haz3lweb/app/editors/code/CodeEditable.re @@ -244,14 +244,19 @@ module View = { }); Deco.editor(model.editor.state.zipper, selected); }; + let projectors_data = + ProjectorView.collect_data( + model.editor.syntax, + model.editor.state.zipper, + model.statics, + dynamics, + ); let projectors = ProjectorView.all( - model.editor.state.zipper, - ~globals, - ~cached_statics=model.statics, - ~cached_syntax=model.editor.syntax, - ~inject=x => inject(Perform(x)), - ~dynamics, + x => inject(Perform(x)), + ProjectorView.mk_utility(globals.font_metrics), + globals.font_metrics, + projectors_data, ); let overlays = [Node.div(~attrs=[Attr.classes(["code-deco"])], edit_decos)] From b603c56e5d583342d9392feea133844e4059ec29 Mon Sep 17 00:00:00 2001 From: disconcision Date: Fri, 17 Jan 2025 13:54:39 -0500 Subject: [PATCH 281/281] cleanup --- src/haz3lweb/app/common/ProjectorView.re | 72 ++++++++----------- src/haz3lweb/app/editors/code/CodeEditable.re | 14 ++-- 2 files changed, 37 insertions(+), 49 deletions(-) diff --git a/src/haz3lweb/app/common/ProjectorView.re b/src/haz3lweb/app/common/ProjectorView.re index 86553f3429..49744dc6f3 100644 --- a/src/haz3lweb/app/common/ProjectorView.re +++ b/src/haz3lweb/app/common/ProjectorView.re @@ -129,26 +129,13 @@ let mk_utility = (font_metrics: FontMetrics.t): ProjectorBase.utility => { }; }; -let mk_info = - ( - id: Id.t, - p: Piece.projector, - ~cached_statics: CachedStatics.t, - ~dynamics: Dynamics.Map.t, - ) - : ProjectorBase.info => { - id, - syntax: p.syntax, - statics: Statics.Map.lookup(id, cached_statics.info_map), - dynamics: Dynamics.Map.lookup(id, dynamics), -}; - let indication = (z, id) => switch (Indicated.piece(z)) { | Some((p, d, _)) when Piece.id(p) == id => Some(Direction.toggle(d)) | _ => None }; +/* Find end of row offset position in grid units */ let offside_base = (~offset: int, measurement: Measured.measurement, measured: Measured.t) : int => @@ -165,32 +152,37 @@ type projector_data = { offside_base: int, }; -let get_data = +let mk_info = ( - id, - cached_syntax: Editor.CachedSyntax.t, - cached_statics: CachedStatics.t, - dynamics: Dynamics.Map.t, - zipper: Zipper.t, + id: Id.t, + p: Piece.projector, + ~cached_statics: CachedStatics.t, + ~dynamics: Dynamics.Map.t, ) - : option(projector_data) => { - let* p = Id.Map.find_opt(id, cached_syntax.projectors); - let+ measurement = Measured.find_pr_opt(p, cached_syntax.measured); - { - p, - indication: indication(zipper, id), - selected: List.mem(id, cached_syntax.selection_ids), - measurement, - info: mk_info(id, p, ~cached_statics, ~dynamics), - offside_base: - offside_base(~offset=4, measurement, cached_syntax.measured), - }; + : ProjectorBase.info => { + id, + syntax: p.syntax, + statics: Statics.Map.lookup(id, cached_statics.info_map), + dynamics: Dynamics.Map.lookup(id, dynamics), }; -let collect_data = (syntax: Editor.CachedSyntax.t, zipper, statics, dynamics) => { - let projector_ids = syntax.projectors |> Id.Map.bindings |> List.rev; +let collect_data = + (cached_syntax: Editor.CachedSyntax.t, zipper, cached_statics, dynamics) => { + let projector_ids = cached_syntax.projectors |> Id.Map.bindings |> List.rev; List.filter_map( - ((id, _)) => get_data(id, syntax, statics, dynamics, zipper), + ((id, _)) => { + let* p = Id.Map.find_opt(id, cached_syntax.projectors); + let+ measurement = Measured.find_pr_opt(p, cached_syntax.measured); + { + p, + indication: indication(zipper, id), + selected: List.mem(id, cached_syntax.selection_ids), + measurement, + info: mk_info(id, p, ~cached_statics, ~dynamics), + offside_base: + offside_base(~offset=4, measurement, cached_syntax.measured), + }; + }, projector_ids, ); }; @@ -260,14 +252,12 @@ let all = inject: Action.t => Ui_effect.t(unit), utility: ProjectorBase.utility, font_metrics: FontMetrics.t, - pairs: list(projector_data), + projector_data: list(projector_data), ) => { - let mk_views = (bleh: projector_data) => { - setup_view(inject, utility, font_metrics, bleh); - }; - let (underlay_views, base_views, overlay_views) = - pairs |> List.map(mk_views) |> ListUtil.split3; + projector_data + |> List.map(setup_view(inject, utility, font_metrics)) + |> ListUtil.split3; let overlay_views = overlay_views |> List.filter_map(Fun.id); [ div_c( diff --git a/src/haz3lweb/app/editors/code/CodeEditable.re b/src/haz3lweb/app/editors/code/CodeEditable.re index 2c74307449..b5bd7bcaa6 100644 --- a/src/haz3lweb/app/editors/code/CodeEditable.re +++ b/src/haz3lweb/app/editors/code/CodeEditable.re @@ -244,19 +244,17 @@ module View = { }); Deco.editor(model.editor.state.zipper, selected); }; - let projectors_data = - ProjectorView.collect_data( - model.editor.syntax, - model.editor.state.zipper, - model.statics, - dynamics, - ); let projectors = ProjectorView.all( x => inject(Perform(x)), ProjectorView.mk_utility(globals.font_metrics), globals.font_metrics, - projectors_data, + ProjectorView.collect_data( + model.editor.syntax, + model.editor.state.zipper, + model.statics, + dynamics, + ), ); let overlays = [Node.div(~attrs=[Attr.classes(["code-deco"])], edit_decos)]